@kienntpixon/dieu-phoi 0.7.0 → 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.0';
+const CORE_VERSION = '0.7.2';
 const SCHEMA = 1;
 const TASK_TYPES = [
   'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',
@@ -270,6 +270,12 @@ 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 === '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
     }
   }
   return tag;
@@ -311,6 +317,27 @@ 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',
+  // 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). */
 function knownTaskTypes(ctx) {
   const out = TASK_TYPES.concat(DEFAULT_EXTRA_TYPES);
@@ -350,10 +377,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 +398,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 +412,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
@@ -601,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)
@@ -649,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;
@@ -667,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 };
       }
     }
@@ -739,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). */
@@ -781,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) {
@@ -801,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);
@@ -1151,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 = [];
@@ -1255,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}/`,
@@ -1267,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) {
@@ -1329,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. */
@@ -1360,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);
@@ -1545,11 +1678,14 @@ function startInfo(ctx, cwd) {
   };
   const k = startKnowledgeOf(cwd);
   if (k) info.knowledge = k;
+  const d = scanUnmergedDeltasFor(ctx);
+  if (hasUnmergedDeltas(d)) 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) {
@@ -1633,6 +1769,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`);
@@ -1666,11 +1808,35 @@ 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). */
+/**
+ * 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;
@@ -1692,7 +1858,7 @@ 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)
@@ -1705,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);
@@ -2421,6 +2587,209 @@ 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 };
+}
+
+/** 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 || {};
+  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 };
+  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();
+    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: {} };
+      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 > 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(/[\\/]+$/, ''))) : '?';
+        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;
+  }
+  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) {
+  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)' : '';
+  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 });
+}
+
 /**
  * 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
@@ -2491,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;
@@ -2518,6 +2897,11 @@ 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.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,
@@ -2543,6 +2927,11 @@ function buildDispatch(p, ctx) {
   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 {};
@@ -2561,6 +2950,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;
 }
 
@@ -2579,12 +2977,21 @@ 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;
     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,
@@ -2594,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>');
@@ -2739,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;
@@ -2761,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,
@@ -2789,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;
@@ -2822,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;
 }
 
@@ -3287,6 +3942,101 @@ 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.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' },
+    { gate_action: 'deny', reason_code: 'handoff-chain', children: n });
+  return {
+    denied: true,
+    event: ev,
+    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ẻ.'),
+  };
+}
+
 /** 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;
@@ -3443,10 +4193,14 @@ 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);
-    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'); }
     }
@@ -3596,22 +4350,22 @@ 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,
-  CORE_VERSION, SCHEMA, TASK_TYPES, URGENCIES, ROLES, MODEL_ALIASES, UNTAGGED,
+  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,
+  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, 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) {