@kienntpixon/dieu-phoi 0.7.1 → 0.7.2

package/hook.cjs

@@ -26,7 +26,7 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 
-const CORE_VERSION = '0.7.1';
+const CORE_VERSION = '0.7.2';
 const SCHEMA = 1;
 const TASK_TYPES = [
   'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',
@@ -272,6 +272,8 @@ function parseTag(text) {
       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 === 'session_ok') {
+      tag.session_ok = true; // core 0.7.2 (K5): the user agreed to open a new root in an oversized session
     } else if (p === 'batch') {
       tag.batch = true; // core 0.7.1 (C5): the one batched verifier of a fast request
     }
@@ -331,6 +333,9 @@ const TYPE_ALIASES = {
   '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',
+  // core 0.7.2 (K6, retro 2026-11-05): labels that still arrived as bad-type in the 11-05 logs
+  'test-run': 'test-write', 'test-verify': 'test-write', 'device-qa': 'test-write',
+  'git-ops': 'mechanical-edit', 'release-build': 'mechanical-edit', 'read-scan': 'search',
 };
 
 /** Fixed task types + the profile's extra_task_types (art-gen when no profile is readable). */
@@ -634,7 +639,7 @@ function summarizeTranscript(lines, opts) {
 // ------------------------------------------------------------------ orchestrator (main session) usage
 
 const SESSION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
-const ORCH_CACHE_V = 2;  // 2: + compactions
+const ORCH_CACHE_V = 2;  // 2: + compactions (0.7.2: a cold-probe cache with compactions null is re-probed, see orchestratorUsage)
 const ORCH_CHUNK = 1 << 20;            // read granularity; memory = chunk + longest line
 const ORCH_SEEN_KEEP = 64;             // requestIds kept for last-line-wins dedupe across scans
 const ORCH_HEAD_BYTES = 4096;          // fingerprint of the file start (rotation / replacement check)
@@ -682,8 +687,9 @@ function ctxOfBuckets(b) {
  * passed to onLine (return true to stop). Returns { consumed: byte just past the last complete line
  * handled, read: bytes read }.
  */
-function scanUsageLines(fd, start, end, onLine) {
+function scanUsageLines(fd, start, end, onLine, needle) {
   const buf = Buffer.allocUnsafe(ORCH_CHUNK);
+  const one = needle || null; // null: usage or compaction lines; else only lines holding `needle`
   let carry = null;
   let pos = start;
   let consumed = start;
@@ -700,8 +706,9 @@ function scanUsageLines(fd, start, end, onLine) {
     while ((nl = data.indexOf(0x0a, s)) >= 0) {
       const line = data.subarray(s, nl);
       s = nl + 1;
-      if ((line.indexOf(USAGE_NEEDLE) >= 0 || line.indexOf(COMPACT_NEEDLE) >= 0)
-        && onLine(line.toString('utf8')) === true) {
+      const hit = one ? line.indexOf(one) >= 0
+        : (line.indexOf(USAGE_NEEDLE) >= 0 || line.indexOf(COMPACT_NEEDLE) >= 0);
+      if (hit && onLine(line.toString('utf8')) === true) {
         return { consumed: base + s, read };
       }
     }
@@ -772,13 +779,22 @@ function edgeProbe(fd, size, st) {
   }
   st.cum_known = false;
   st.requests = null;
-  st.compactions = null; // unknown until a full scan
+  st.offset = lastNl >= 0 ? lastNl + 1 : 0;
+  // core 0.7.2 (K5): count compactions over [0, offset) too (byte scan, JSON only on hits). The incremental
+  // scan takes over from offset, so nothing is counted twice; before 0.7.2 this stayed null for the session.
+  st.compactions = countCompactions(fd, st.offset);
   if (first) {
     st.baseline = ctxOfBuckets(usageBuckets(first.usage));
     st.baseline_req = first.key;
   }
   if (last) st.last_ctx = ctxOfBuckets(usageBuckets(last.usage));
-  st.offset = lastNl >= 0 ? lastNl + 1 : 0;
+}
+
+/** Main-thread compaction markers in [0, end) (sidechain and look-alike text ignored). Never throws. */
+function countCompactions(fd, end) {
+  let n = 0;
+  if (end > 0) scanUsageLines(fd, 0, end, (t) => { const u = parseMainLine(t); if (u && u.compact) n++; return false; }, COMPACT_NEEDLE);
+  return n;
 }
 
 /** Drop stale session caches. Only ever touches <data>/orch/*.json (never another directory). */
@@ -814,8 +830,9 @@ function orchCacheFile(paths, sessionId, transcriptPath) {
  * opts.cacheFile: per-session state ({offset, cost, seen requestIds, baseline, …}); each call then parses
  *   only the bytes appended since the last call. A shrunk or replaced file (offset > size or a different
  *   head fingerprint) is recomputed from 0.
- * opts.coldMaxBytes: no usable cache and the file is larger -> head/tail probe only (ctx + baseline,
- *   cum_usd null); a later call without the limit (`dieu-phoi ctx`) recomputes the full sum.
+ * opts.coldMaxBytes: no usable cache and the file is larger -> head/tail probe (ctx + baseline, cum_usd null)
+ *   plus a byte scan of the compaction markers before the probe offset; a later call without the limit
+ *   (`dieu-phoi ctx`) recomputes the full sum.
  * Reads in chunks (memory = chunk + longest line), never the whole file at once. Never throws.
  */
 function orchestratorUsage(transcriptPath, pricing, opts) {
@@ -834,7 +851,8 @@ function orchestratorUsage(transcriptPath, pricing, opts) {
     const cached = o.cacheFile ? readJsonFile(o.cacheFile, null) : null;
     if (cached && cached.v === ORCH_CACHE_V && Number.isFinite(cached.offset) && cached.offset <= size
       && cached.head_len <= size && Array.isArray(cached.seen)
-      && (cached.cum_known || o.coldMaxBytes)) {
+      && (cached.cum_known || (o.coldMaxBytes && typeof cached.compactions === 'number'))) {
+      // a probe state written before 0.7.2 holds compactions null: not reused, so the probe counts it (cum_known kept)
       const now = cached.head_len === fp.head_len ? fp : (() => {
         const b = Buffer.alloc(cached.head_len);
         if (cached.head_len) fs.readSync(fd, b, 0, cached.head_len, 0);
@@ -1184,7 +1202,8 @@ function buildSessionState(events, sessionId, opts) {
       const id = ev.task_id || agentTask.get(ev.agent_id);
       if (per.has(id)) per.get(id).steers.push(ev);
     }
-    if (ev.kind === 'override' && per.has(ev.task_id)) per.get(ev.task_id).overrides.push(ev);
+    // core 0.7.2 (K4): an implicit override is a recorded deviation, not the user's choice: it never moves the approved tier
+    if (ev.kind === 'override' && ev.source !== 'implicit' && per.has(ev.task_id)) per.get(ev.task_id).overrides.push(ev);
   }
   const byTime = (a, b) => evMs(a) - evMs(b) || a._i - b._i;
   const tasks = [];
@@ -1288,7 +1307,8 @@ function buildSessionState(events, sessionId, opts) {
       mode_suggest: sug.mode_suggest, mode_suggest_reason: sug.mode_suggest_reason,
     };
   });
-  return {
+  const orphans = findOrphanAgents(events, taskIds.filter((id) => !discarded.has(id)), { nowMs: o.nowMs });
+  return Object.assign({
     session_id: sessionId,
     generated_at: nowIso(),
     runs_dir: `${runs}/`,
@@ -1300,7 +1320,85 @@ function buildSessionState(events, sessionId, opts) {
       steps: p.steps.length, run_dir: `${runs}/${p.root_task_id}/`,
     })),
     tasks,
-  };
+  }, orphans.length ? { orphans } : {});
+}
+
+// retro 2026-11-05 K2: orphan agents. An exec/verify/plan agent whose LAST segment ended without a STATUS:/VERDICT: line
+// (`complete.ended_without_status`; older events: status "none"), or that never reported ending, and that has no agent
+// verdict, no newer dispatch of the same task+role and no user/auto accept, is listed so the orchestrator re-dispatches
+// (try+1) or drops it instead of waiting forever. Pure function of the events; never reads run-dir files.
+const ORPHAN_MIN_MS = 15 * 60 * 1000;
+// An agent with no `complete` at all may simply still be running in the background (state is rebuilt right after /compact):
+// only after this long is it called orphaned, and the line says to ignore it when the agent is still alive.
+const ORPHAN_NO_COMPLETE_MS = 2 * 3600 * 1000;
+const ORPHAN_MAX_LINES = 6;
+
+function findOrphanAgents(events, taskIds, opts) {
+  const now = (opts && opts.nowMs) || Date.now();
+  const want = new Set(taskIds || []);
+  const seenAgent = new Set();
+  const latest = new Map(); // "task|role" -> newest dispatch
+  const lastComplete = new Map();
+  const judged = new Set(); // agent ids with any verdict
+  const accepted = new Set();
+  for (const ev of events) {
+    if (!ev || typeof ev !== 'object') continue;
+    if (ev.kind === 'dispatch' && want.has(ev.task_id) && !seenAgent.has(ev.agent_id)) {
+      const role = ev.role || 'exec';
+      if (!RESULT_ROLES.includes(role)) continue;
+      seenAgent.add(ev.agent_id);
+      latest.set(`${ev.task_id}|${role}`, ev);
+    } else if (ev.kind === 'complete') {
+      lastComplete.set(ev.agent_id, ev);
+    } else if (ev.kind === 'verdict') {
+      if (ev.agent_id) judged.add(ev.agent_id);
+      if (ev.task_id && ev.outcome === 'accept') accepted.add(ev.task_id);
+      else if (ev.task_id && (ev.outcome === 'reject' || ev.outcome === 'rework')) accepted.delete(ev.task_id);
+    }
+  }
+  const out = [];
+  for (const d of latest.values()) {
+    if (judged.has(d.agent_id) || accepted.has(d.task_id)) continue;
+    const c = lastComplete.get(d.agent_id);
+    let reason;
+    let since;
+    if (c) {
+      const ended = c.ended_without_status === true || (c.ended_without_status === undefined && c.status === 'none');
+      if (!ended) continue;
+      since = evMs(c);
+      if (!since || now - since < ORPHAN_MIN_MS) continue;
+      reason = c.inline_result === true ? 'inline' : 'no-status';
+    } else {
+      since = evMs(d);
+      if (!since || now - since < ORPHAN_NO_COMPLETE_MS) continue;
+      reason = 'no-complete';
+    }
+    out.push({
+      task_id: d.task_id, agent_id: d.agent_id, role: d.role || 'exec', try: Number(d.try) || 1, task_type: d.task_type || null,
+      score: Number.isFinite(d.score) ? d.score : null, urgency: d.urgency || 'normal', reason, age_min: Math.round((now - since) / 60000),
+    });
+  }
+  return out;
+}
+
+const ORPHAN_REASON_TEXT = {
+  'no-status': 'kết thúc mà báo cáo cuối không có dòng STATUS:/VERDICT:',
+  inline: 'không ghi file dp-out (hook chỉ lưu .inline.md) và không có dòng STATUS:/VERDICT:',
+  'no-complete': 'không thấy kết thúc (nếu agent còn chạy nền thì bỏ qua dòng này)',
+};
+
+/** Lines telling the orchestrator what to do with each orphan agent (at most ORPHAN_MAX_LINES). [] when none. */
+function orphanLines(orphans) {
+  const list = Array.isArray(orphans) ? orphans : [];
+  if (!list.length) return [];
+  const lines = [`agent mồ côi: ${list.length} lượt giao chưa có kết quả dùng được, chưa verdict, chưa giao lại — đọc dp-out/.inline.md của bước (nếu có) rồi giao lại hoặc bỏ:`];
+  for (const x of list.slice(0, ORPHAN_MAX_LINES)) {
+    lines.push(`  - ${x.task_id} [${x.task_type || '?'}] ${x.role} try${x.try} (${x.agent_id}) — ${ORPHAN_REASON_TEXT[x.reason] || x.reason}, ${x.age_min} phút trước; `
+      + `giao lại: [dp:${x.task_type || '<type>'}|s${x.score === null ? '<n>' : x.score}|${x.urgency}|try${x.try + 1}|task=${x.task_id}|role=${x.role}]; `
+      + `bỏ: dieu-phoi verdict ${x.agent_id} fail --reason ${x.reason === 'no-complete' ? 'no-complete' : 'ended-without-status'}`);
+  }
+  if (list.length > ORPHAN_MAX_LINES) lines.push(`  (+${list.length - ORPHAN_MAX_LINES} nữa — xem đủ: dieu-phoi state --json, khoá orphans)`);
+  return lines;
 }
 
 function toPosix(p) {
@@ -1362,7 +1460,8 @@ function stateCounts(state) {
 /** One short Vietnamese line shown to the user after /compact re-injected the state. */
 function compactSystemMessage(state) {
   const c = stateCounts(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)`;
+  const orph = Array.isArray(state.orphans) && state.orphans.length ? `, ${state.orphans.length} agent mồ côi` : '';
+  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${orph})`;
 }
 
 /** "\nMode: <root>=<mode> …" for the roots of a session (last 6); '' when the state carries none. */
@@ -1393,7 +1492,8 @@ function formatSessionState(state, cap) {
   const render = (omitted) => {
     const body = stateBody(state, kept);
     const tail = omitted ? `\n(bỏ bớt ${omitted} task cũ nhất để vừa ${limit} ký tự; xem đủ: dieu-phoi state --json)` : '';
-    return `${header}\n${body.join('\n')}${tail}`;
+    const orph = orphanLines(state.orphans);
+    return `${header}\n${body.join('\n')}${tail}${orph.length ? `\n${orph.join('\n')}` : ''}`;
   };
   let omitted = 0;
   let text = render(0);
@@ -1578,8 +1678,8 @@ function startInfo(ctx, cwd) {
   };
   const k = startKnowledgeOf(cwd);
   if (k) info.knowledge = k;
-  const d = scanUnmergedDeltas();
-  if (d.count) info.unmerged_deltas = d;
+  const d = scanUnmergedDeltasFor(ctx);
+  if (hasUnmergedDeltas(d)) info.unmerged_deltas = d;
   return info;
 }
 
@@ -1715,6 +1815,28 @@ 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). */
+/**
+ * Core 0.7.2 (K3/K5): whether events.jsonl holds a dispatch for any task in `taskIds` (optionally only of `role`).
+ * Same substring scan as countTaskHandoffs: rare path, one read of the file.
+ */
+function hasDispatchFor(ctx, taskIds, role) {
+  let txt;
+  try { txt = fs.readFileSync(ctx.paths.events, 'utf8'); } catch (_) { return false; }
+  for (const id of taskIds) {
+    if (!id) continue;
+    const needle = `"task_id":${JSON.stringify(id)}`;
+    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"') && (!role || line.includes(`"role":${JSON.stringify(role)}`))) return true;
+      i = end < 0 ? -1 : txt.indexOf(needle, end);
+    }
+  }
+  return false;
+}
+
 function countTaskHandoffs(ctx, taskId) {
   if (!taskId) return 0;
   let txt;
@@ -1749,9 +1871,9 @@ function handoffChainMessage(taskId, n) {
 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>`';
+const LOCAL_ONLY_KINDS = new Set(['mode', 'knowledge_merge', 'leftover', 'worktree']);
+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>`';
 
 function isMode(m) {
   return typeof m === 'string' && MODES.includes(m);
@@ -2528,9 +2650,48 @@ function storeByName(name, stores) {
   return { matches, store: matches.length === 1 ? matches[0] : null };
 }
 
+/** Task id a delta file belongs to: knowledge-delta-<task_id>[-r<n>|-h<n>].md (8 chars a-z0-9); null = untagged. */
+function deltaTagOf(file) {
+  const m = /^knowledge-delta-([a-z0-9]{8})(?:-[rh]\d+)?\.md$/i.exec(path.basename(String(file)));
+  return m ? m[1].toLowerCase() : null;
+}
+
+/**
+ * retro 11-05 (K1): who has judged what, from events + approved plans. `deltaState(run, tag)` is the user's decision on
+ * a delta file in run dir `run` ('accept' | 'reject' | null): a tagged file follows the LAST user verdict of its task;
+ * an untagged one (or one tagged with the run id) follows the tasks living in that run (own id, plan members,
+ * dispatch `run`): accept when any of them was accepted, reject when all were rejected, else null.
+ */
+function deltaClassifier(events, plansDir) {
+  const last = new Map();
+  const runOf = new Map();
+  for (const e of events || []) {
+    if (!e || !e.task_id) continue;
+    if (e.kind === 'verdict' && e.by === 'user' && (e.outcome === 'accept' || e.outcome === 'reject')) last.set(e.task_id, e.outcome);
+    if (e.kind === 'dispatch' && typeof e.run === 'string' && e.run) runOf.set(e.task_id, e.run);
+  }
+  const planRoot = new Map();
+  for (const p of loadPlans(plansDir)) for (const x of p.steps) if (x && x.task_id) planRoot.set(x.task_id, p.root_task_id);
+  const byRun = new Map();
+  const add = (run, t) => { if (!byRun.has(run)) byRun.set(run, new Set()); byRun.get(run).add(t); };
+  for (const t of last.keys()) { add(t, t); if (planRoot.has(t)) add(planRoot.get(t), t); if (runOf.has(t)) add(runOf.get(t), t); }
+  return {
+    state: (t) => last.get(t) || null,
+    deltaState(run, tag) {
+      if (tag && tag !== run) return last.get(tag) || null;
+      const ts = Array.from(byRun.get(run) || []).map((t) => last.get(t));
+      if (!ts.length) return null;
+      return ts.includes('accept') ? 'accept' : 'reject';
+    },
+  };
+}
+
 /**
  * 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.
+ * With opts.events (+ opts.plansDir) the files are split by what the user decided: count/runs = no user verdict yet
+ * (24 h .. 30 d old); `accepted` = { count, runs: [{ run, n, oldest_ms, repos, tasks, untagged }] } = ALREADY ACCEPTED but
+ * not merged (an error: no age floor, only the 30 d window); a task the user rejected is left out of both.
  */
 function scanUnmergedDeltas(opts) {
   const o = opts || {};
@@ -2538,6 +2699,8 @@ function scanUnmergedDeltas(opts) {
   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 };
+  const cls = Array.isArray(o.events) ? deltaClassifier(o.events, o.plansDir) : null;
+  const acc = { count: 0, runs: [] };
   try {
     const runs = runsDir();
     const applied = new Set();
@@ -2551,26 +2714,36 @@ function scanUnmergedDeltas(opts) {
       let names;
       try { names = fs.readdirSync(dir); } catch (_) { continue; }
       const row = { run, n: 0, oldest_ms: 0, repos: {} };
+      const arow = { run, n: 0, oldest_ms: 0, repos: {}, tasks: [], untagged: false };
       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 (age > windowMs) continue;
+        const tag = deltaTagOf(f);
+        const verdict = cls ? cls.deltaState(run, tag) : null;
+        if (verdict === 'reject') continue;
+        const into = verdict === 'accept' ? arow : row;
+        if (into === row && age < warnMs) 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;
+        into.n++;
+        into.oldest_ms = Math.max(into.oldest_ms, age);
+        into.repos[label] = (into.repos[label] || 0) + 1;
+        if (into === arow) { if (tag && tag !== run) { if (!arow.tasks.includes(tag)) arow.tasks.push(tag); } else arow.untagged = true; }
       }
       if (row.n) { res.runs.push(row); res.count += row.n; }
+      if (arow.n) { acc.runs.push(arow); acc.count += arow.n; }
       if (res.truncated) break;
     }
     res.runs.sort((a, b) => b.n - a.n || b.oldest_ms - a.oldest_ms);
+    acc.runs.sort((a, b) => b.n - a.n || b.oldest_ms - a.oldest_ms);
+    if (acc.count) res.accepted = acc;
   } catch (e) {
     res.error = e.message;
   }
@@ -2583,15 +2756,38 @@ function ageText(ms) {
 
 /** 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 out = [];
+  const a = scan && scan.accepted;
+  if (a && a.count) {
+    const r0 = a.runs[0];
+    const cmd = `dieu-phoi knowledge merge --run ${r0.run}${r0.tasks.length ? ` --task ${r0.tasks.slice(0, 8).join(',')}` : ''}${r0.untagged ? ' --untagged' : ''}`;
+    const runText = a.runs.slice(0, 3).map((r) => `${r.run} ×${r.n}`).join(', ') + (a.runs.length > 3 ? ` (+${a.runs.length - 3} run)` : '');
+    out.push(`knowledge_delta_accepted: LỖI — ${a.count} file delta của task ĐÃ nghiệm thu mà chưa vào kho (gộp lúc accept thất bại hoặc bị bỏ sót) — run ${runText}; cũ nhất ${ageText(Math.max(...a.runs.map((r) => r.oldest_ms)))}. `
+      + `Gộp: \`${cmd} --dry-run\` rồi bỏ --dry-run.`);
+  }
+  if (!scan || !scan.count) return out;
   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.`];
+  const pending = scan.accepted ? ' (chưa có verdict người dùng)' : '';
+  out.push(`knowledge_delta: ${scan.count} file delta chưa gộp quá 24h${pending}${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.`);
+  return out;
+}
+
+/** Whether a scan has anything to show (undecided and/or accepted-but-unmerged deltas). */
+function hasUnmergedDeltas(scan) {
+  return !!(scan && (scan.count || (scan.accepted && scan.accepted.count)));
+}
+
+/** scanUnmergedDeltas with the user's verdicts (events + approved plans of ctx), so accepted-unmerged is told apart. */
+function scanUnmergedDeltasFor(ctx) {
+  let events = [];
+  try { events = readEvents(ctx); } catch (_) { /* no log: everything stays undecided */ }
+  return scanUnmergedDeltas({ events, plansDir: ctx && ctx.paths && ctx.paths.plans });
 }
 
 /**
@@ -2664,6 +2860,16 @@ function projectFields(p) {
   return {};
 }
 
+/** Run dir id the brief points at (retro 11-05 K1: accept finds the delta there whatever the plan/root says), else null. */
+function dispatchRun(prompt) {
+  try {
+    const probe = 'norundir0'; // resultRunDir falls back to runs/<task_id>: the probe id tells "named in the brief" from that fallback
+    const d = resultRunDir(prompt, probe);
+    const id = path.basename(d);
+    return path.dirname(d) === path.resolve(runsDir()) && id !== probe && /^[A-Za-z0-9_-]{1,64}$/.test(id) ? id : null;
+  } catch (_) { return null; }
+}
+
 function buildDispatch(p, ctx) {
   const ti = p.tool_input && typeof p.tool_input === 'object' ? p.tool_input : {};
   const tr = p.tool_response;
@@ -2693,7 +2899,9 @@ function buildDispatch(p, ctx) {
     ...(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.session_ok ? { session_ok: true } : {}),
     ...(tag.batch ? { batch: true } : {}),
+    ...(dispatchRun(ti.prompt) ? { run: dispatchRun(ti.prompt) } : {}),
     task_type: tag.task_type,
     score: tag.score,
     urgency: tag.urgency,
@@ -2775,7 +2983,15 @@ function handlePostToolUse(p, ctx) {
     if (n) ev.task_handoffs = n;
     if (n >= HANDOFF_CHAIN_WARN) notes.push(handoffChainMessage(ev.task_id, n));
   }
+  // core 0.7.2 (K4): an exec with no choose record gets a reminder; a tier that differs from choose's answer without an
+  // override logged for it leaves an implicit override event right after the dispatch.
+  let implicit = null;
+  if (ev.task_id && ev.role === 'exec' && isValidTaskId(ev.task_id)) {
+    if (!ev.suggested_tier) notes.push(noChooseMessage(ev.task_id));
+    else implicit = implicitOverrideEvent(ctx, ev);
+  }
   appendEvent(ctx, ev);
+  if (implicit) appendEvent(ctx, implicit);
   if (notes.length) {
     Object.defineProperty(ev, 'stdout', {
       enumerable: false,
@@ -2785,6 +3001,51 @@ function handlePostToolUse(p, ctx) {
   return ev;
 }
 
+/** core 0.7.2 (K4): reminder for an exec whose task has no choose record (data/suggest) when it was dispatched. */
+function noChooseMessage(taskId) {
+  return `dieu-phoi: exec của task ${taskId} được giao mà chưa có kết quả \`choose\` (không có tier trong data/suggest). Lần giao sau chạy \`dieu-phoi choose --type <task_type> --task ${taskId} --json\` trước khi giao; tier giao khác tier choose trả mà không có --override sẽ được ghi là override implicit.`;
+}
+
+/**
+ * core 0.7.2 (K4): the implicit override for an exec dispatch whose tier differs from what choose answered
+ * (choose_tier, else suggested_tier) while no override of this task to that tier is logged yet. Null otherwise.
+ */
+function implicitOverrideEvent(ctx, ev) {
+  const dispatched = ev.dispatched_tier;
+  const said = ev.choose_tier || ev.suggested_tier;
+  if (!dispatched || dispatched.includes('?') || dispatched === said) return null;
+  if (overrideLoggedFor(ctx, ev.task_id, dispatched)) return null;
+  return Object.assign({
+    schema: SCHEMA,
+    kind: 'override',
+    ts: nowIso(),
+    agent_id: `task:${ev.task_id}`,
+    task_id: ev.task_id,
+    task_type: ev.task_type || null,
+    suggested_tier: said,
+    chosen_tier: dispatched,
+    source: 'implicit',
+  }, commonFields(ctx));
+}
+
+/** Whether events.jsonl already holds an override (explicit or implicit) of this task to this tier. */
+function overrideLoggedFor(ctx, taskId, tier) {
+  let txt;
+  try { txt = fs.readFileSync(ctx.paths.events, 'utf8'); } catch (_) { return false; }
+  const needle = `"task_id":${JSON.stringify(taskId)}`;
+  let i = txt.indexOf('"kind":"override"');
+  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(needle)) {
+      try { if (JSON.parse(line).chosen_tier === tier) return true; } catch (_) { /* a junk line never matches */ }
+    }
+    i = end < 0 ? -1 : txt.indexOf('"kind":"override"', end);
+  }
+  return false;
+}
+
 function hasAssistantUsage(lines) {
   return lines.some((l) => l && l.type === 'assistant' && l.message && l.message.usage
     && l.message.model !== '<synthetic>');
@@ -2930,6 +3191,101 @@ function persistInlineResult(lines, tag, opts) {
   return file;
 }
 
+// s15 (core 0.7.2): tools that start background work an agent may leave running, and the tools that stop it.
+// s16 (core 0.7.2): the formats below were checked against real subagent transcripts (Claude Code, 2026-11):
+//  - Bash/PowerShell result "Command running in background with ID: <id>. Output is being written to: ..." appears for
+//    run_in_background:true and also when a long foreground command is moved to the background by itself (no flag);
+//  - Monitor result "Monitor started (task <id>, timeout ...)" (no "ID:"); a refused Monitor is a tool_result is_error:true;
+//  - TaskStop input {task_id}, the same id;
+//  - task finished = a <task-notification> carrying <status> (+ <task-id>, <tool-use-id>). It is delivered mostly as an
+//    `attachment` line (attachment.type "queued_command", attachment.origin "task-notification", XML in attachment.prompt),
+//    sometimes as a user line with string content. A <task-notification> without <status> is a Monitor progress <event>.
+const BG_START_TOOLS = new Set(['Bash', 'PowerShell', 'Monitor']);
+const BG_SHELL_TOOLS = new Set(['Bash', 'PowerShell']);
+const BG_STOP_TOOLS = new Set(['TaskStop', 'KillShell']);
+const BG_ID_RE = /\bID:\s*([A-Za-z0-9_-]{2,64})/;
+const BG_MONITOR_ID_RE = /\(task\s+([A-Za-z0-9_-]{2,64})[,)]/;
+const BG_AUTO_RE = /^\s*Command running in background with ID:/; // anchored: test/grep output may quote the phrase
+const NOTIF_BLOCK_RE = /<task-notification>[\s\S]*?<\/task-notification>/g;
+const TASK_ID_TAG_RE = /<task-id>\s*([A-Za-z0-9_-]{2,64})\s*<\/task-id>/;
+const TOOL_USE_ID_TAG_RE = /<tool-use-id>\s*([A-Za-z0-9_-]{2,80})\s*<\/tool-use-id>/;
+
+function textOfContent(c) {
+  if (typeof c === 'string') return c;
+  if (!Array.isArray(c)) return '';
+  return c.map((b) => (b && b.type === 'text' && typeof b.text === 'string' ? b.text : '')).join('\n');
+}
+
+/**
+ * s15/s16: background work an agent opened and did not stop, read from its transcript (pure; returns ids, never a command).
+ * Opened = a Bash/PowerShell tool_use with run_in_background:true, or whose result says "Command running in background
+ * with ID:" (a long command moved to the background by itself), or a Monitor tool_use whose result is not an error. The id
+ * comes from the tool_result ("... ID: <id>" / "(task <id>, ..."); without one the tool_use id stands in. Closed = a
+ * TaskStop/KillShell whose input names the id, or a finished-task <task-notification> (one with <status>) naming the id
+ * or the tool_use id, wherever it sits (queued_command attachment, user text). Returns the ids still open, in start order.
+ */
+function openBackgroundTasks(lines) {
+  const open = new Map(); // tool_use id -> task id, null while no id is known
+  const finished = new Set(); // task ids and tool_use ids named by a stop or a finished notice (may precede the start result)
+  const kinds = new Map(); // tool_use id -> tool name of every candidate start
+  const flagged = new Set(); // tool_use ids that asked for the background or are Monitors
+  const close = (id) => {
+    finished.add(id);
+    for (const [k, v] of open) if (k === id || v === id) open.delete(k);
+  };
+  const closeNotified = (text) => {
+    if (!text || !text.includes('<task-notification>')) return;
+    for (const blk of text.match(NOTIF_BLOCK_RE) || []) {
+      if (!blk.includes('<status>')) continue; // a Monitor <event> notice: the task is still running
+      const t = TASK_ID_TAG_RE.exec(blk);
+      const u = TOOL_USE_ID_TAG_RE.exec(blk);
+      if (t) close(t[1]);
+      if (u) close(u[1]);
+    }
+  };
+  for (const l of Array.isArray(lines) ? lines : []) {
+    if (!l) continue;
+    if (l.type === 'attachment') {
+      const a = l.attachment;
+      if (a && a.type === 'queued_command' && typeof a.prompt === 'string') closeNotified(a.prompt);
+      continue;
+    }
+    const msg = l.message;
+    if (!msg) continue;
+    const isUser = l.type === 'user';
+    if (typeof msg.content === 'string') {
+      if (isUser) closeNotified(msg.content);
+      continue;
+    }
+    if (!Array.isArray(msg.content)) continue;
+    for (const b of msg.content) {
+      if (!b || typeof b !== 'object') continue;
+      if (b.type === 'tool_use' && typeof b.id === 'string') {
+        const input = b.input && typeof b.input === 'object' ? b.input : {};
+        if (BG_START_TOOLS.has(b.name)) {
+          kinds.set(b.id, b.name);
+          if (b.name === 'Monitor' || input.run_in_background === true) flagged.add(b.id);
+        } else if (BG_STOP_TOOLS.has(b.name)) {
+          const id = input.task_id || input.shell_id;
+          if (typeof id === 'string' && id) close(id);
+        }
+      } else if (b.type === 'tool_result' && kinds.has(b.tool_use_id)) {
+        const text = textOfContent(b.content);
+        const kind = kinds.get(b.tool_use_id);
+        const auto = BG_SHELL_TOOLS.has(kind) && BG_AUTO_RE.test(text);
+        if ((!flagged.has(b.tool_use_id) && !auto) || b.is_error === true) continue; // foreground, or refused: nothing started
+        const m = (kind === 'Monitor' ? BG_MONITOR_ID_RE.exec(text) : null) || BG_ID_RE.exec(text);
+        const id = m ? m[1] : null;
+        if (finished.has(b.tool_use_id) || (id && finished.has(id))) continue;
+        open.set(b.tool_use_id, id);
+      } else if (b.type === 'text' && typeof b.text === 'string' && isUser) {
+        closeNotified(b.text);
+      }
+    }
+  }
+  return Array.from(open, ([k, v]) => v || k);
+}
+
 function handleSubagentStop(p, ctx) {
   const agentId = typeof p.agent_id === 'string' && p.agent_id ? p.agent_id : null;
   if (!agentId) return null;
@@ -2952,6 +3308,14 @@ function handleSubagentStop(p, ctx) {
     sum = summarizeTranscript(lines, { afterUuids: seen, pricing: loadPricing(ctx) });
     tag = tagFromTranscript(lines, knownTaskTypes(ctx));
   }
+  // s15 (core 0.7.2): a tagged dp-* agent that stops while a background task it opened still runs is sent back once
+  // (decision block: TaskStop it, then report). That second stop has stop_hook_active true: recorded, never blocked again.
+  // The blocked stop writes nothing, so the next stop still counts the whole segment.
+  const leftover = tag && tag.task_id ? openBackgroundTasks(lines) : [];
+  if (leftover.length && p.stop_hook_active !== true && ctx.config.block_leftover_tasks !== false) {
+    const reason = `Còn task nền chưa dừng: ${leftover.slice(0, 5).join(', ')}. TaskStop từng cái rồi trả lại STATUS.`;
+    return { stdout: `${JSON.stringify({ decision: 'block', reason })}\n` };
+  }
   const t = tag || UNTAGGED;
   const ev = Object.assign({
     schema: SCHEMA,
@@ -2980,12 +3344,18 @@ function handleSubagentStop(p, ctx) {
   ev.handoff = ev.status === 'handoff';
   ev.peak_ctx = sum ? sum.peak_ctx : null;
   ev.compactions = sum ? sum.compactions : null;
+  // s15: background tasks still open when the segment ended (after the one allowed block): a count, never the commands
+  if (leftover.length) ev.leftover_tasks = leftover.length;
   let inline = null;
   if (exists && tag) {
     try { inline = persistInlineResult(lines, tag, { finalText: p.last_assistant_message }); } catch (_) { /* best effort */ }
   }
   // 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);
+  if (tag && RESULT_ROLES.includes(tag.role)) {
+    ev.inline_result = Boolean(inline);
+    // retro 2026-11-05 K2: the segment ended with no STATUS:/VERDICT: line (or no final text) and was neither a quota pause nor a handoff
+    ev.ended_without_status = exists && (ev.status === 'none' || ev.status === null);
+  }
   // 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;
@@ -3013,6 +3383,100 @@ function handleSubagentStop(p, ctx) {
       verify: 'none', reason_code: `auto-${why}`, cause: null, round: null,
     }, commonFields(ctx)));
   }
+  // s16 (core 0.7.2): processes the agent left behind (report; kill only with config kill_leftovers). Never throws, bounded to ~5 s.
+  if (tag && tag.task_id && exists) {
+    try { scanLeftoverProcs(ctx, { agentId, taskId: tag.task_id, lines }); } catch (e) { logError(ctx.home, e, 'leftover-procs'); }
+  }
+  return ev;
+}
+
+// ------------------------------------------------------------------ leftover processes (s16, core 0.7.2)
+
+// The process-table helpers live in lib/procs.cjs. The installed hook is a single copied file, so `setup` puts the same
+// module next to it as bin/procs.cjs; the repo layout finds it under ./lib. Missing module = no scan, never an error.
+function loadProcs() {
+  for (const f of ['./procs.cjs', './lib/procs.cjs']) {
+    try { return require(f); } catch (_) { /* try the next place */ }
+  }
+  return null;
+}
+
+const LEFTOVER_BUDGET_MS = 5000;
+const LEFTOVER_LIST_TIMEOUT_MS = 4000;
+const LEFTOVER_OVERLAP_MAX_AGE_MS = 24 * 3600 * 1000;
+
+/** Start of an agent transcript (first line timestamp, epoch ms) or null. */
+function transcriptStartMs(lines) {
+  for (const l of Array.isArray(lines) ? lines : []) {
+    const t = l && typeof l.timestamp === 'string' ? Date.parse(l.timestamp) : NaN;
+    if (Number.isFinite(t)) return t;
+  }
+  return null;
+}
+
+/**
+ * Is another dp agent alive during [startMs, endMs]? From dispatch/complete events: dispatched at or before endMs and not
+ * completed before startMs (a foreground agent's dispatch is logged when it returns, so it counts too: the safe side).
+ * Dispatches older than 24 h without a complete are ignored (crashed agents).
+ */
+function otherAgentsRunning(events, agentId, startMs, endMs) {
+  const disp = new Map();
+  const done = new Map();
+  for (const ev of Array.isArray(events) ? events : []) {
+    if (!ev || !ev.agent_id || ev.agent_id === agentId) continue;
+    const t = Date.parse(ev.ts);
+    if (!Number.isFinite(t)) continue;
+    if (ev.kind === 'dispatch') disp.set(ev.agent_id, Math.max(disp.get(ev.agent_id) || 0, t));
+    else if (ev.kind === 'complete') done.set(ev.agent_id, Math.max(done.get(ev.agent_id) || 0, t));
+  }
+  for (const [id, d] of disp) {
+    if (d > endMs) continue;
+    const c = done.get(id);
+    if (c === undefined) { if (endMs - d <= LEFTOVER_OVERLAP_MAX_AGE_MS) return true; continue; }
+    if (c >= startMs) return true;
+  }
+  return false;
+}
+
+/**
+ * Looks at the process table after a dp agent stopped. Descendants of this session's Claude Code process created since the
+ * agent started and still alive (not the hook's own chain, not claude/code-graph) -> one local `leftover` event
+ * {task_id, n, names}. They are only reported, unless config kill_leftovers is true AND no other dp agent ran in the
+ * meantime (then the leftover trees are killed). deps = { procs, now, selfPid, events } for tests. Returns the event or null.
+ */
+function scanLeftoverProcs(ctx, a, deps) {
+  const d = deps || {};
+  if (ctx.config.scan_leftover_procs === false || (!d.procs && process.env.DIEU_PHOI_NO_PROCS === '1')) return null;
+  const procs = d.procs || loadProcs();
+  if (!procs) return null;
+  const startMs = transcriptStartMs(a.lines);
+  const now = typeof d.now === 'number' ? d.now : Date.now();
+  // an agent that started over 24 h ago (a long-resumed or odd transcript) has no meaningful "created since" window
+  if (startMs === null || now - startMs > LEFTOVER_OVERLAP_MAX_AGE_MS) return null;
+  const t0 = Date.now();
+  const list = procs.listProcesses({ timeoutMs: LEFTOVER_LIST_TIMEOUT_MS });
+  if (!Array.isArray(list)) return null;
+  const selfPid = d.selfPid || process.pid;
+  const root = procs.claudeAncestor(list, selfPid);
+  if (!root) return null;
+  const left = procs.leftoverProcesses(list, { rootPid: root.pid, startMs, selfPid });
+  if (!left.all.length) return null;
+  const counts = new Map();
+  for (const p of left.all) { const n = String(p.name || '?').toLowerCase(); counts.set(n, (counts.get(n) || 0) + 1); }
+  const names = Array.from(counts).sort((x, y) => y[1] - x[1] || (x[0] < y[0] ? -1 : 1)).slice(0, 8).map((x) => x[0]);
+  const killOn = ctx.config.kill_leftovers === true;
+  let killed = 0;
+  let skipped = null;
+  if (killOn) {
+    const events = d.events || readEvents(ctx);
+    if (otherAgentsRunning(events, a.agentId, startMs, now)) skipped = 'other-agent-running';
+    else killed = procs.killTree(left.roots.map((p) => p.pid), { deadline: t0 + LEFTOVER_BUDGET_MS }).length;
+  }
+  const ev = Object.assign({
+    schema: SCHEMA, kind: 'leftover', ts: nowIso(), agent_id: a.agentId, task_id: a.taskId,
+    n: left.all.length, names, kill_leftovers: killOn, killed,
+  }, skipped ? { kill_skipped: skipped } : {}, commonFields(ctx));
+  appendEvent(ctx, ev);
   return ev;
 }
 
@@ -3488,7 +3952,22 @@ function handleChainGate(p, ctx) {
   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;
+  if (!tag || !tag.task_id || !isValidTaskId(tag.task_id)) return null;
+  if (tag.role === 'verify') return verifyOrphanGate(p, ctx, tag);
+  if (tag.role !== 'exec') return null;
+  const chain = tag.chain_ok ? null : chainGateDenial(p, ctx, tag);
+  if (chain) return chain;
+  return sessionCapGate(p, ctx, tag);
+}
+
+function preToolDeny(reason) {
+  return JSON.stringify({
+    hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: reason },
+  });
+}
+
+/** Core 0.7.1 (C1): exec continuation of a task that already handed off HANDOFF_CHAIN_DENY times. */
+function chainGateDenial(p, ctx, tag) {
   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' },
@@ -3496,15 +3975,65 @@ function handleChainGate(p, ctx) {
   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ẻ.',
-      },
-    }),
+    stdout: preToolDeny(`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ẻ.'),
+  };
+}
+
+/**
+ * Core 0.7.2 (K3, retro 2026-11-05): a `role=verify` dispatch whose task has no exec dispatch in events.jsonl and sits
+ * in no approved plan is a verifier for work that was never dispatched -> denied (`verify-orphan`). `|batch` (the one
+ * verifier of a fast request, covering several steps) is exempt.
+ */
+function verifyOrphanGate(p, ctx, tag) {
+  if (tag.batch) return null;
+  if (hasDispatchFor(ctx, [tag.task_id], 'exec')) return null;
+  if (planOfTask(ctx, tag.task_id)) return null;
+  const ev = logGate(ctx, p, `task:${tag.task_id}`, { task_id: tag.task_id, role: 'verify' },
+    { gate_action: 'deny', reason_code: 'verify-orphan' });
+  return {
+    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`.'),
+  };
+}
+
+/** Core 0.7.2 (K5): trần phiên điều phối cứng. Vượt một trong hai → exec mở ROOT MỚI bị chặn (session-cap). */
+const SESSION_CAP_TOKENS = 800000;
+const SESSION_CAP_COMPACTIONS = 10;
+
+/**
+ * Core 0.7.2 (K5, retro 2026-11-05): the orchestrating session is past SESSION_CAP_TOKENS of context or
+ * SESSION_CAP_COMPACTIONS compactions. An exec that opens a new root is denied (`session-cap`); an exec of a root that
+ * already has a dispatch (a continuation) passes; `|session_ok` lets the user accept the risk. Main-session only.
+ */
+function sessionCapGate(p, ctx, tag) {
+  if (tag.session_ok) return null;
+  const plans = loadPlans(ctx.paths.plans);
+  const step = planOfTask(ctx, tag.task_id);
+  const root = step ? step.root : tag.task_id;
+  if (hasDispatchFor(ctx, rootTaskIds(plans, root), null)) return null;
+  const u = orchestratorUsage(p.transcript_path, loadPricing(ctx), {
+    cacheFile: orchCacheFile(ctx.paths, p.session_id, p.transcript_path),
+    coldMaxBytes: HOOK_COLD_MAX_BYTES,
+  });
+  const tokens = typeof u.ctx_tokens === 'number' ? u.ctx_tokens : null;
+  const comp = typeof u.compactions === 'number' ? u.compactions : null;
+  const over = (tokens !== null && tokens > SESSION_CAP_TOKENS) || (comp !== null && comp >= SESSION_CAP_COMPACTIONS);
+  if (!over) return null;
+  const ev = logGate(ctx, p, `task:${tag.task_id}`, { task_id: tag.task_id, role: 'exec' },
+    { gate_action: 'deny', reason_code: 'session-cap' });
+  const sid = p.session_id || '<session>';
+  return {
+    denied: true,
+    event: ev,
+    stdout: preToolDeny(`dieu-phoi: phiên điều phối đã chạm trần cứng (context ${tokens === null ? '?' : tokens} token, `
+      + `${comp === null ? '?' : comp} lần nén; trần ${SESSION_CAP_TOKENS} token hoặc ${SESSION_CAP_COMPACTIONS} lần nén) — `
+      + `không mở root mới trong phiên này. Đừng /compact thêm: ghi trạng thái (\`dieu-phoi state --session ${sid}\` + file trạng thái trong run dir), `
+      + 'trình phần đã xong, rồi MỞ PHIÊN MỚI và nạp lại từ state; giao root mới từ phiên đó. '
+      + 'Chỉ khi người dùng đồng ý giao ngay ở đây: thêm `|session_ok` vào thẻ.'),
   };
 }
 
@@ -3667,8 +4196,11 @@ function runHook(opts) {
     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);
-    else if (name === 'PostToolUse' || (!name && p.tool_name)) ev = handlePostToolUse(p, ctx);
+    if (name === 'SubagentStop') {
+      const r = handleSubagentStop(p, ctx);
+      if (r && typeof r.stdout === 'string') return r; // s15: block decision, printed as the hook's JSON answer
+      ev = r;
+    } else if (name === 'PostToolUse' || (!name && p.tool_name)) ev = handlePostToolUse(p, ctx);
     if (ev) {
       try { maybeSpawnSync(ctx); } catch (e) { logError(home, e, 'spawn-sync'); }
     }
@@ -3818,7 +4350,7 @@ async function runSync(ctx, opts) {
 // ------------------------------------------------------------------ exports / main
 
 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,
+  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,
   testCommandInfo, testTimeOf, testSFromText,
@@ -3828,12 +4360,12 @@ module.exports = {
   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,
+  RESULT_ROLES, BLOCKED_RESULT_NAME_RE, resultFileName, findResultFiles, resultRunDir, finalAssistantText, persistInlineResult, orchestratorUsage, countCompactions, orchCacheFile, findSessionTranscript, SESSION_ID_RE, HOOK_COLD_MAX_BYTES, SESSION_CAP_TOKENS, SESSION_CAP_COMPACTIONS, 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, deltaHash, deltaRepoOf, isBareRepoName, storeCatalog, storeByName, scanUnmergedDeltas, unmergedDeltaLines, DELTA_WARN_MS, 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, scanUnmergedDeltasFor, unmergedDeltaLines, hasUnmergedDeltas, deltaTagOf, deltaClassifier, dispatchRun, DELTA_WARN_MS, DELTA_WINDOW_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,
+  extractAgentId, hasAssistantUsage, hasDispatch, buildDispatch, handlePostToolUse, handleSubagentStop, openBackgroundTasks, scanLeftoverProcs, otherAgentsRunning, maybeSpawnSync, runHook, runSync,
 };
 
 if (require.main === module) {