@kienntpixon/dieu-phoi 0.7.1 → 0.7.3

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.3';
 const SCHEMA = 1;
 const TASK_TYPES = [
   'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',
@@ -272,6 +272,10 @@ 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 === 'parallel_ok') {
+      tag.parallel_ok = true; // core 0.7.3 (s1): the user agreed to dispatch past the parallel cap
     } else if (p === 'batch') {
       tag.batch = true; // core 0.7.1 (C5): the one batched verifier of a fast request
     }
@@ -331,6 +335,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 +641,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 +689,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 +708,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 +781,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 +832,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 +853,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 +1204,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 +1309,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 +1322,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 +1462,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 +1494,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 +1680,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;
 }
 
@@ -1615,11 +1717,18 @@ function formatStartBlock(info) {
 
 /** UserPromptSubmit: on a dieu-phoi prompt, pre-create the run and inject id/run dir/health/brief. */
 function handleUserPromptSubmit(p, ctx) {
-  if (!isDieuPhoiPrompt(p.prompt)) return null;
+  // s6: stuck/orphaned agents of this session → TaskStop + reap reminder, on any prompt (not only dieu-phoi ones)
+  const stuck = typeof p.session_id === 'string' && p.session_id && !watchAgentId(p) ? stuckReminder(ctx, { sessionId: p.session_id }) : null;
+  if (!isDieuPhoiPrompt(p.prompt)) {
+    if (!stuck) return null;
+    return { stdout: JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: stuck } }), stuck: true };
+  }
   const info = startInfo(ctx, typeof p.cwd === 'string' ? p.cwd : null);
+  const text = stuck ? `${formatStartBlock(info)}
+${stuck}` : formatStartBlock(info);
   return {
     stdout: JSON.stringify({
-      hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: formatStartBlock(info) },
+      hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: text },
     }),
     info,
   };
@@ -1715,6 +1824,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 +1880,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', 'reap', 'reap_orphans']);
+const MODE_ASK_LINE = 'mode: chưa chọn — chỉ hỏi ở cổng 1 khi plan-table báo ≥4 bước s≤6 (fast | normal | strict, mặc định normal); '
+  + 'đặt bằng `dieu-phoi mode --root <root_task_id> <mode>`';
 
 function isMode(m) {
   return typeof m === 'string' && MODES.includes(m);
@@ -2528,9 +2659,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 +2708,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 +2723,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 +2765,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 +2869,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 +2908,10 @@ 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.parallel_ok ? { parallel_ok: true } : {}),
     ...(tag.batch ? { batch: true } : {}),
+    ...(dispatchRun(ti.prompt) ? { run: dispatchRun(ti.prompt) } : {}),
     task_type: tag.task_type,
     score: tag.score,
     urgency: tag.urgency,
@@ -2710,7 +2928,7 @@ function buildDispatch(p, ctx) {
     orch_ctx_baseline: orch.ctx_baseline,
     orch_compactions: orch.compactions,
     orch_cum_usd: orch.cum_usd,
-  }, tag.parent_task_id ? { parent_task_id: tag.parent_task_id } : {},
+  }, dispatchLiveCounts(ctx, p, tag), tag.parent_task_id ? { parent_task_id: tag.parent_task_id } : {},
   projectFields(p),
   modeFields(ctx, tag),
   tierFields(ctx, tag, normalizeModel(trObj.resolvedModel) || normalizeModel(ti.model) || null, explicitEffort || parentEffort || null),
@@ -2775,7 +2993,21 @@ 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);
+  // s6: the orchestrator just dispatched: remind it of its stuck/orphaned agents (main session only; an exec hears about
+  // its own helpers through --watch)
+  if (!watchAgentId(p) && typeof p.session_id === 'string' && p.session_id) {
+    const stuck = stuckReminder(ctx, { sessionId: p.session_id });
+    if (stuck) notes.push(stuck);
+  }
   if (notes.length) {
     Object.defineProperty(ev, 'stdout', {
       enumerable: false,
@@ -2785,6 +3017,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,7 +3207,102 @@ function persistInlineResult(lines, tag, opts) {
   return file;
 }
 
-function handleSubagentStop(p, ctx) {
+// 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, opt) {
   const agentId = typeof p.agent_id === 'string' && p.agent_id ? p.agent_id : null;
   if (!agentId) return null;
   const prev = loadSegments(ctx, agentId);
@@ -2952,6 +3324,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 +3360,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,9 +3399,180 @@ 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) {
+    const live = opt && opt.live ? opt.live : null;
+    try {
+      scanLeftoverProcs(ctx, {
+        agentId, taskId: tag.task_id, lines, worktree: live && live.cwd ? live.cwd : null, liveStart: live ? live.start : null,
+        sessionCwd: typeof p.cwd === 'string' ? p.cwd : null,
+        sessionTranscript: typeof p.transcript_path === 'string' ? p.transcript_path : (live && live.session_transcript) || null,
+      });
+    } 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}. kill_leftovers (procs.killMode: env → config → 'guarded'):
+ *   - 'guarded' (default, s7): kill only what procs.guardedSelect attributes to this agent (agent shell under this session's
+ *     claude.exe, never-kill list, cmd in its own worktree or no other dp agent meanwhile), each pid re-checked against a
+ *     fresh list (same creation time) right before; killed_pids + kill_skips {pid, name, reason} go in the event;
+ *   - true: 0.7.2 behaviour, the leftover tree roots (taskkill /T) when no other dp agent ran meanwhile; false: report only.
+ * deps = { procs, now, selfPid, events, kill } 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) || (a.liveStart ? Date.parse(a.liveStart) || null : null);
+  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 mode = typeof procs.killMode === 'function' ? procs.killMode(ctx.config) : (ctx.config.kill_leftovers === true ? 'tree' : 'off');
+  let killed = 0;
+  let skipped = null;
+  const extra = {};
+  if (mode === 'tree') {
+    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;
+  } else if (mode === 'guarded') {
+    // s7: kill only what is attributable to THIS agent, after re-checking pid + creation time; pids + reasons go in the event
+    const events = d.events || readEvents(ctx);
+    const otherAgent = otherAgentsRunning(events, a.agentId, startMs, now);
+    const mainShell = !otherAgent && (typeof d.mainShell === 'boolean' ? d.mainShell : mainShellSince(a.sessionTranscript, startMs));
+    const exclusive = !otherAgent && !mainShell;
+    const sel = procs.guardedSelect(list, left.all, { rootPid: root.pid, worktree: ownWorktree(ctx, a, now), exclusive });
+    const res = sel.kill.length
+      ? procs.killVerified(sel.kill, { relist: () => procs.listProcesses({ timeoutMs: LEFTOVER_LIST_TIMEOUT_MS }), kill: d.kill, deadline: t0 + LEFTOVER_BUDGET_MS })
+      : { killed: [], skipped: [] };
+    killed = res.killed.length;
+    const skips = sel.skip.concat(res.skipped);
+    if (!exclusive && sel.skip.some((s) => s.reason === 'not-attributable')) skipped = otherAgent ? 'other-agent-running' : 'main-thread-shell';
+    extra.killed_pids = res.killed.slice(0, 20);
+    if (skips.length) extra.kill_skips = skips.slice(0, 20).map((s) => ({ pid: s.pid, name: String(s.name || '').toLowerCase(), reason: s.reason }));
+  }
+  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: typeof procs.killModeValue === 'function' ? procs.killModeValue(mode) : mode === 'tree', killed,
+  }, extra, skipped ? { kill_skipped: skipped } : {}, commonFields(ctx));
+  appendEvent(ctx, ev);
   return ev;
 }
 
+const MAIN_SHELL_TAIL_BYTES = 4 * 1024 * 1024;
+const MAIN_SHELL_TOOLS = new Set(['Bash', 'PowerShell', 'Monitor']);
+
+/**
+ * Did the session's main thread start a shell (Bash / PowerShell / Monitor tool_use) at or after startMs? Its processes sit
+ * under the same claude.exe as the agent's, so "no other dp agent ran" is not enough to call the tree the agent's. Reads the
+ * last 4 MB of the session transcript. true = yes OR unknown (unreadable, or the tail does not reach back to startMs).
+ */
+function mainShellSince(file, startMs) {
+  if (typeof file !== 'string' || !file || !startMs) return true;
+  let fd;
+  try { fd = fs.openSync(file, 'r'); } catch (_) { return true; }
+  try {
+    const size = fs.fstatSync(fd).size;
+    const from = Math.max(0, size - MAIN_SHELL_TAIL_BYTES);
+    const text = readSlice(fd, from, size - from).toString('utf8');
+    const lines = text.split('\n');
+    if (from > 0) lines.shift(); // partial first line
+    let oldest = Infinity;
+    for (const raw of lines) {
+      if (!raw.trim()) continue;
+      let l;
+      try { l = JSON.parse(raw); } catch (_) { continue; }
+      const t = typeof l.timestamp === 'string' ? Date.parse(l.timestamp) : NaN;
+      if (Number.isFinite(t)) oldest = Math.min(oldest, t);
+      if (!(t >= startMs) || l.isSidechain) continue;
+      const content = l.message && Array.isArray(l.message.content) ? l.message.content : [];
+      if (content.some((c) => c && c.type === 'tool_use' && MAIN_SHELL_TOOLS.has(c.name))) return true;
+    }
+    return from > 0 && !(oldest <= startMs); // tail too short to see the whole window: unknown
+  } catch (_) {
+    return true;
+  } finally {
+    try { fs.closeSync(fd); } catch (_) { /* closed */ }
+  }
+}
+
+/**
+ * The agent's own worktree for the guarded kill: its live-record cwd (brief `worktree:` or SubagentStart cwd), only when it is
+ * not the session's own cwd and no other live agent works in it (a shared directory says nothing about whose process it is).
+ */
+function ownWorktree(ctx, a, now) {
+  const norm = (s) => String(s || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+  const wt = norm(a.worktree);
+  if (!wt || (a.sessionCwd && norm(a.sessionCwd) === wt)) return null;
+  let others = [];
+  try { others = readLive(ctx, now).agents.filter((r) => r.agent_id !== a.agentId); } catch (_) { others = []; }
+  return others.some((r) => norm(r.cwd) === wt) ? null : a.worktree;
+}
+
 // Exact marker an agent puts on the FIRST line of its final report when it stops at a safe point because of a quota
 // / usage limit (brief template A, SKILL.md). Nothing looser: "STATUS: partial" + "quota" can be a real failure
 // ("Drive storage quota exceeded", a half-built rate limiter).
@@ -3405,6 +3962,17 @@ function handleWatch(p, ctx, o) {
   if (!agentId) return null;
   const { st, file, tpath } = watchState(p, ctx, agentId);
   if (!st || !st.dp || !tpath) return null;
+  const touched = touchLive(ctx, p, agentId, st); // core 0.7.3 (s1): live register heartbeat
+  // s6: an exec's own stuck helpers (checked at most once per heartbeat, i.e. ≤ 1/30 s)
+  const helperNote = touched && st.role === 'exec' && st.task_id ? stuckReminder(ctx, { parentTask: st.task_id }) : null;
+  const withHelperNote = (r) => {
+    if (!helperNote) return r;
+    if (!r) return { stuck: true, stdout: JSON.stringify({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: helperNote } }) };
+    const out = JSON.parse(r.stdout);
+    out.hookSpecificOutput.additionalContext += `\n${helperNote}`;
+    r.stdout = JSON.stringify(out);
+    return r;
+  };
   // Gate slots: a helper's first hook proves its spawn started; so does the exec's own successful Agent call.
   if (st.role === 'helper' && st.parent_task_id && st.task_id) gateConfirm(ctx, st.parent_task_id, st.task_id);
   if ((p.tool_name === 'Agent' || p.tool_name === 'Task') && st.role === 'exec') {
@@ -3413,21 +3981,21 @@ function handleWatch(p, ctx, o) {
   }
   const thresholds = Array.isArray(o && o.thresholds) && o.thresholds.length ? o.thresholds : watchThresholds(ctx);
   const tokens = lastContextTokens(tpath);
-  if (tokens === null) return null;
+  if (tokens === null) return withHelperNote(null);
   let level = 0;
   while (level < thresholds.length && tokens >= thresholds[level]) level++;
-  if (level <= (Number(st.fired) || 0)) return null;
+  if (level <= (Number(st.fired) || 0)) return withHelperNote(null);
   st.fired = level;
   st.ctx_tokens = tokens;
   st.t = Date.now();
   writeFileAtomic(file, `${JSON.stringify(st)}\n`);
-  return {
+  return withHelperNote({
     level,
     ctx_tokens: tokens,
     stdout: JSON.stringify({
       hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: handoffMessage(st, tokens, level, thresholds) },
     }),
-  };
+  });
 }
 
 /** A reservation that neither the parent's PostToolUse(Agent) nor the helper's own first hook confirmed in this long never started. */
@@ -3478,6 +4046,514 @@ function gateReserve(dir, child) {
   return 0;
 }
 
+// ------------------------------------------------------------------ live agents + parallel cap (core 0.7.3 s1)
+
+/**
+ * Live-agent register `data/live/<agent_id>.json`: written at SubagentStart, refreshed by --watch (last_activity, at most
+ * once per LIVE_TOUCH_MS), removed at SubagentStop, ignored (and deleted) once idle past LIVE_TTL_MS. Counting is a
+ * readdir of small files, cheap enough for PreToolUse. The SubagentStart payload has no prompt (only session_id,
+ * agent_id, agent_type, cwd — checked 2026-11-06 with a probe session) and the subagent transcript does not exist yet,
+ * so the tag comes from an intent `live/pending/<session8>-<task>-<role>.json` that the allowing PreToolUse(Agent)
+ * (main session) or --gate (gen-2 helper) wrote: SubagentStart claims the oldest unclaimed intent of the same session
+ * and agent_type with an exclusive `.claim` create. No intent → a dp-* agent_type still gets a file (role from the
+ * type, task unknown, filled in by its first --watch); any other subagent (Claude Code internal, untagged) is skipped.
+ */
+const LIVE_TTL_MS = 6 * 3600 * 1000;
+const LIVE_TOUCH_MS = 30 * 1000;
+/** An unclaimed intent counts towards the cap this long (the spawn it announces has not started yet). */
+const LIVE_PENDING_MS = 60 * 1000;
+/** SubagentStart may still claim an intent this old (a permission prompt can sit between PreToolUse and the spawn). */
+const LIVE_CLAIM_MS = 10 * 60 * 1000;
+const PARALLEL_DEFAULTS = { max_parallel_session: 4, max_parallel_machine: 8, warn_parallel_machine: 6 };
+/** Roles the per-session cap counts (gen 1 dispatches of the orchestrator). The machine cap counts every live agent. */
+const LIVE_SESSION_ROLES = ['exec', 'plan', 'verify'];
+const AGENT_TYPE_ROLES = { 'dp-exec': 'exec', 'dp-verify': 'verify', 'dp-scout': 'plan', 'dp-helper': 'helper' };
+
+function liveName(id) {
+  return String(id).replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 80) || 'x';
+}
+function liveDir(ctx) { return path.join(ctx.paths.data, 'live'); }
+function liveFile(ctx, agentId) { return path.join(liveDir(ctx), `${liveName(agentId)}.json`); }
+function livePendingDir(ctx) { return path.join(liveDir(ctx), 'pending'); }
+function intentFile(ctx, sessionId, taskId, role) {
+  return path.join(livePendingDir(ctx), `${sha8(String(sessionId || ''))}-${liveName(taskId || 'none')}-${liveName(role || 'exec')}.json`);
+}
+
+/** Caps: env DIEU_PHOI_<KEY> → config.json → PARALLEL_DEFAULTS. Integers ≥ 0; 0 turns that cap (or warning) off. */
+function parallelLimits(ctx) {
+  const cfg = (ctx && ctx.config) || {};
+  const pick = (key) => {
+    for (const v of [process.env[`DIEU_PHOI_${key.toUpperCase()}`], cfg[key]]) {
+      if (v === undefined || v === null || v === '') continue;
+      const n = Number(v);
+      if (Number.isFinite(n) && n >= 0) return Math.floor(n);
+    }
+    return PARALLEL_DEFAULTS[key];
+  };
+  return { session: pick('max_parallel_session'), machine: pick('max_parallel_machine'), warn: pick('warn_parallel_machine') };
+}
+
+function liveMs(v) {
+  const n = typeof v === 'number' ? v : Date.parse(v);
+  return Number.isFinite(n) ? n : null;
+}
+
+/** Live agents + still-pending intents. Files idle past LIVE_TTL_MS are deleted and not returned. Never throws. */
+function readLive(ctx, now) {
+  const t = typeof now === 'number' ? now : Date.now();
+  const agents = [];
+  const pending = [];
+  let names = [];
+  try { names = fs.readdirSync(liveDir(ctx)); } catch (_) { return { agents, pending }; }
+  for (const n of names) {
+    if (!n.endsWith('.json')) continue;
+    const f = path.join(liveDir(ctx), n);
+    const r = readJsonFile(f, null);
+    const last = r && typeof r === 'object' ? (liveMs(r.last_activity) || liveMs(r.start)) : null;
+    if (last === null || t - last > LIVE_TTL_MS) {
+      // unreadable: give a concurrent writer a moment before treating it as junk
+      let old = true;
+      if (last === null) { try { old = t - fs.statSync(f).mtimeMs > LIVE_TOUCH_MS; } catch (_) { old = false; } }
+      if (old) { try { fs.unlinkSync(f); } catch (_) { /* gone already */ } }
+      continue;
+    }
+    agents.push(r);
+  }
+  let pnames = [];
+  try { pnames = fs.readdirSync(livePendingDir(ctx)); } catch (_) { pnames = []; }
+  const claimed = new Set(pnames.filter((n) => n.endsWith('.claim')).map((n) => n.slice(0, -6)));
+  for (const n of pnames) {
+    if (!n.endsWith('.json')) continue;
+    const f = path.join(livePendingDir(ctx), n);
+    const r = readJsonFile(f, null);
+    const at = r && typeof r === 'object' ? liveMs(r.t) : null;
+    if (at === null || t - at > LIVE_TTL_MS) {
+      try { fs.unlinkSync(f); } catch (_) { /* ignore */ }
+      try { fs.unlinkSync(`${f.slice(0, -5)}.claim`); } catch (_) { /* ignore */ }
+      continue;
+    }
+    if (claimed.has(n.slice(0, -5)) || t - at > LIVE_PENDING_MS) continue;
+    pending.push(Object.assign({ pending: true }, r));
+  }
+  return { agents, pending };
+}
+
+/** session = exec/plan/verify (gen 1) of `sessionId`, live or pending; machine = every live agent + pending intent. */
+function liveCounts(live, sessionId) {
+  const all = live.agents.concat(live.pending);
+  const mine = all.filter((r) => sessionId && r.session_id === sessionId && LIVE_SESSION_ROLES.includes(r.role) && !(Number(r.gen) > 1));
+  return { session: mine.length, machine: all.length, mine, all };
+}
+
+function liveAgeMin(r, now) {
+  const s = liveMs(r.start) || liveMs(r.t);
+  return s === null ? null : Math.max(0, Math.round((now - s) / 60000));
+}
+
+function liveLabel(r, now, withSession) {
+  const age = liveAgeMin(r, now);
+  const bits = [r.role || '?'];
+  if (age !== null) bits.push(`${age} phút`);
+  if (r.pending) bits.push('vừa giao');
+  if (withSession && r.session_id) bits.push(`phiên ${sha8(r.session_id)}`);
+  return `${r.task_id || (r.agent_id ? `agent ${r.agent_id}` : '?')} (${bits.join(', ')})`;
+}
+
+/** s6: run dir the brief points at (dp-out-/handoff- path or …/runs/<id>), else null — never the made-up fallback. */
+function briefRunDir(prompt, taskId) {
+  if (typeof prompt !== 'string' || !prompt) return null;
+  const d = resultRunDir(prompt, taskId || 'none');
+  const fallback = path.join(runsDir(), safeName(taskId || 'none'));
+  return d === fallback && !/\/runs\/[A-Za-z0-9_-]/.test(prompt.replace(/\\/g, '/')) ? null : d;
+}
+
+/** s6: where Claude Code will write a subagent's transcript, from the parent's transcript_path at SubagentStart. */
+function liveTranscriptGuess(parentTp, agentId) {
+  if (typeof parentTp !== 'string' || !parentTp || !agentId) return null;
+  const name = `agent-${agentId}.jsonl`;
+  if (path.basename(path.dirname(parentTp)) === 'subagents') return path.join(path.dirname(parentTp), name); // nested spawn
+  return path.join(path.dirname(parentTp), path.basename(parentTp, '.jsonl'), 'subagents', name);
+}
+
+/** Absolute path on the brief's `worktree:` line (best effort), else null. */
+function briefWorktree(prompt) {
+  if (typeof prompt !== 'string') return null;
+  const m = /^\s*worktree:(.*)$/m.exec(prompt);
+  if (!m) return null;
+  const pm = /([A-Za-z]:[\\/][^\s,;`'"()]+|\/[^\s,;`'"()]+)/.exec(m[1]);
+  return pm ? pm[1].replace(/[.)]+$/, '') : null;
+}
+
+function writeIntent(ctx, p, tag, extra) {
+  try {
+    const f = intentFile(ctx, p.session_id, tag.task_id, tag.role);
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    try { fs.unlinkSync(`${f.slice(0, -5)}.claim`); } catch (_) { /* no earlier claim */ }
+    const ti = p.tool_input && typeof p.tool_input === 'object' ? p.tool_input : {};
+    writeFileAtomic(f, `${JSON.stringify(Object.assign({
+      session_id: typeof p.session_id === 'string' ? p.session_id : null,
+      task_id: tag.task_id || null,
+      role: tag.role || 'exec',
+      gen: 1,
+      agent_type: typeof ti.subagent_type === 'string' && ti.subagent_type ? ti.subagent_type : 'general-purpose',
+      parent_task_id: tag.parent_task_id || null,
+      worktree: briefWorktree(ti.prompt),
+      run_dir: briefRunDir(ti.prompt, tag.task_id), // s6: where its dp-out/STATUS lands (stuck after-status)
+      t: Date.now(),
+    }, extra || {}))}\n`);
+    return f;
+  } catch (e) {
+    logError(ctx.home, e, 'live-intent');
+    return null;
+  }
+}
+
+/** Oldest unclaimed intent of this session + agent_type; claimed by exclusive create so two parallel starts never share one. */
+function claimIntent(ctx, sessionId, agentType, agentId, now) {
+  const dir = livePendingDir(ctx);
+  let names = [];
+  try { names = fs.readdirSync(dir); } catch (_) { return null; }
+  const set = new Set(names);
+  const cands = [];
+  for (const n of names) {
+    if (!n.endsWith('.json') || set.has(`${n.slice(0, -5)}.claim`)) continue;
+    const r = readJsonFile(path.join(dir, n), null);
+    if (!r || r.session_id !== sessionId || r.agent_type !== agentType) continue;
+    const at = liveMs(r.t);
+    if (at === null || now - at > LIVE_CLAIM_MS) continue;
+    cands.push({ n, r, at });
+  }
+  cands.sort((a, b) => a.at - b.at);
+  for (const c of cands) {
+    try {
+      fs.writeFileSync(path.join(dir, `${c.n.slice(0, -5)}.claim`), `${agentId}\n`, { flag: 'wx' });
+      return c.r;
+    } catch (_) { /* another start claimed it */ }
+  }
+  return null;
+}
+
+/** SubagentStart: register the agent (see the block comment above). Prints nothing. Returns the record or null. */
+function handleSubagentStart(p, ctx) {
+  const agentId = typeof p.agent_id === 'string' && p.agent_id ? p.agent_id : null;
+  if (!agentId) return null;
+  const type = typeof p.agent_type === 'string' && p.agent_type ? p.agent_type : 'general-purpose';
+  const sid = typeof p.session_id === 'string' && p.session_id ? p.session_id : null;
+  const now = Date.now();
+  const intent = claimIntent(ctx, sid, type, agentId, now);
+  if (!intent && !AGENT_TYPE_ROLES[type]) return null; // internal / untagged subagent: not ours
+  const role = intent ? intent.role : AGENT_TYPE_ROLES[type];
+  const ts = new Date(now).toISOString();
+  const rec = {
+    agent_id: agentId,
+    session_id: sid,
+    task_id: intent ? intent.task_id : null,
+    role,
+    gen: intent ? (Number(intent.gen) || 1) : (role === 'helper' ? 2 : 1),
+    agent_type: type,
+    parent_task_id: intent ? intent.parent_task_id || null : null,
+    start: ts,
+    last_activity: ts,
+    cwd: (intent && intent.worktree) || (typeof p.cwd === 'string' ? p.cwd : null),
+    live_session: intent && typeof intent.live_session === 'number' ? intent.live_session : null,
+    live_machine: intent && typeof intent.live_machine === 'number' ? intent.live_machine : null,
+    // s6: liveness evidence for `reap` / the stuck reminder (the transcript does not exist yet at SubagentStart)
+    transcript: liveTranscriptGuess(p.transcript_path, agentId),
+    session_transcript: typeof p.transcript_path === 'string' && p.transcript_path ? p.transcript_path : null,
+    run_dir: intent && typeof intent.run_dir === 'string' ? intent.run_dir : null,
+  };
+  fs.mkdirSync(liveDir(ctx), { recursive: true });
+  writeFileAtomic(liveFile(ctx, agentId), `${JSON.stringify(rec)}\n`);
+  // core 0.7.3 (s5): one counts-only sample per registered agent (no disk IO, no paths) for `dieu-phoi load report`
+  appendLoadSample(ctx, Object.assign({ ts, src: 'start' }, liveLoadCounts(ctx, now)));
+  return rec;
+}
+
+/** core 0.7.3 (s5): data/load.jsonl, one JSON object per line (written by SubagentStart and `dieu-phoi load sample`). */
+function loadFile(ctx) { return path.join(ctx.paths.data, 'load.jsonl'); }
+
+/**
+ * Counts for a load sample, read the same way as the cap: per-session exec/plan/verify (gen 1, keyed by sha8 of the
+ * session), every live agent + pending intent, and queue = intents still waiting for their SubagentStart. No IO.
+ */
+function liveLoadCounts(ctx, now) {
+  try {
+    const live = readLive(ctx, now);
+    const bySession = {};
+    for (const r of live.agents.concat(live.pending)) {
+      if (!r.session_id || !LIVE_SESSION_ROLES.includes(r.role) || Number(r.gen) > 1) continue;
+      const k = sha8(r.session_id);
+      bySession[k] = (bySession[k] || 0) + 1;
+    }
+    return { live_session_counts: bySession, live_machine: live.agents.length + live.pending.length, queue: live.pending.length };
+  } catch (_) {
+    return { live_session_counts: {}, live_machine: null, queue: null };
+  }
+}
+
+/** Appends one sample line to data/load.jsonl. Never throws. */
+function appendLoadSample(ctx, rec) {
+  try {
+    fs.mkdirSync(ctx.paths.data, { recursive: true });
+    fs.appendFileSync(loadFile(ctx), `${JSON.stringify(rec)}\n`);
+    return true;
+  } catch (e) {
+    logError(ctx.home, e, 'load-sample');
+    return false;
+  }
+}
+
+/** SubagentStop: the agent is no longer live. */
+function removeLive(ctx, agentId) {
+  if (!agentId) return false;
+  try { fs.unlinkSync(liveFile(ctx, agentId)); return true; } catch (_) { return false; }
+}
+
+/** --watch: refresh last_activity (≤ once per LIVE_TOUCH_MS), fill a missing task from the watch state; create if absent. */
+function touchLive(ctx, p, agentId, st) {
+  try {
+    const f = liveFile(ctx, agentId);
+    const now = Date.now();
+    const rec = readJsonFile(f, null);
+    if (rec && typeof rec === 'object') {
+      const fill = !rec.task_id && st.task_id;
+      if (!fill && now - (liveMs(rec.last_activity) || 0) < LIVE_TOUCH_MS) return false;
+      rec.last_activity = new Date(now).toISOString();
+      if (!rec.transcript || !fs.existsSync(rec.transcript)) rec.transcript = subagentTranscriptPath(p, agentId) || rec.transcript || null;
+      if (fill) { rec.task_id = st.task_id; if (st.role) rec.role = st.role; if (st.parent_task_id) rec.parent_task_id = st.parent_task_id; }
+      writeFileAtomic(f, `${JSON.stringify(rec)}\n`);
+      return true;
+    }
+    // no SubagentStart record (hook registered after the agent started, or an older setup): register it now
+    const ts = new Date(now).toISOString();
+    fs.mkdirSync(liveDir(ctx), { recursive: true });
+    writeFileAtomic(f, `${JSON.stringify({
+      agent_id: agentId, session_id: typeof p.session_id === 'string' ? p.session_id : null,
+      task_id: st.task_id || null, role: st.role || 'exec', gen: st.role === 'helper' || st.parent_task_id ? 2 : 1,
+      agent_type: null, parent_task_id: st.parent_task_id || null, start: ts, last_activity: ts,
+      cwd: typeof p.cwd === 'string' ? p.cwd : null, live_session: null, live_machine: null, from_watch: true,
+      transcript: subagentTranscriptPath(p, agentId), session_transcript: null, run_dir: null,
+    })}\n`);
+    return true;
+  } catch (e) {
+    logError(ctx.home, e, 'live-touch');
+    return false;
+  }
+}
+
+/** Counts for the dispatch event: those recorded when the dispatch was allowed (intent), else the current ones. */
+function dispatchLiveCounts(ctx, p, tag) {
+  try {
+    if (tag && tag.task_id) {
+      const r = readJsonFile(intentFile(ctx, p.session_id, tag.task_id, tag.role), null);
+      if (r && typeof r.live_session === 'number' && typeof r.live_machine === 'number') {
+        return { live_session: r.live_session, live_machine: r.live_machine };
+      }
+    }
+    const c = liveCounts(readLive(ctx), p.session_id);
+    return { live_session: c.session, live_machine: c.machine };
+  } catch (_) {
+    return { live_session: null, live_machine: null };
+  }
+}
+
+function parallelDenyText(scope, c, lim, tag, now) {
+  const list = scope === 'session' ? c.mine : c.all;
+  const shown = list.slice().sort((a, b) => (liveMs(a.start) || liveMs(a.t) || 0) - (liveMs(b.start) || liveMs(b.t) || 0));
+  const names = shown.slice(0, 8).map((r) => liveLabel(r, now, scope === 'machine')).join('; ');
+  const head = scope === 'session'
+    ? `dieu-phoi: phiên này đã có ${c.session}/${lim.session} agent exec/plan/verify đang chạy (trần max_parallel_session)`
+    : `dieu-phoi: toàn máy đã có ${c.machine}/${lim.machine} agent dieu-phoi đang chạy, gồm helper (trần max_parallel_machine)`;
+  const first = shown[0] ? (shown[0].task_id || shown[0].agent_id) : null;
+  return `${head} — chưa giao ${tag.role} của task ${tag.task_id}. Đang chạy: ${names}${list.length > 8 ? ` (+${list.length - 8})` : ''}. `
+    + `Chờ ${first ? `agent ${first}` : 'một agent'} (hoặc agent khác trong danh sách) xong — có thông báo hoàn tất — rồi giao lại đúng lời gọi này; `
+    + 'trong lúc chờ đừng giao thêm. Agent kẹt thì TaskStop nó trước; agent mồ côi (crash, không có SubagentStop) vẫn giữ chỗ — `dieu-phoi reap` xem, `reap --yes` dọn. '
+    + 'Chỉ khi người dùng đồng ý vượt trần: thêm `|parallel_ok` vào thẻ (tắt hẳn: max_parallel_session / max_parallel_machine = 0 trong config.json).';
+}
+
+/**
+ * Core 0.7.3 (s1): PreToolUse(Agent) of the orchestrating session. A dp dispatch with role exec/plan/verify is denied
+ * (`parallel-cap`) while the session already runs max_parallel_session of them, or the machine (this DIEU_PHOI_HOME)
+ * max_parallel_machine dp agents; `|parallel_ok` passes. An allowed dispatch leaves an intent for SubagentStart, and
+ * at warn_parallel_machine it answers with an additionalContext warning instead of nothing.
+ */
+function parallelCapGate(p, ctx, tag) {
+  const now = Date.now();
+  const lim = parallelLimits(ctx);
+  const c = liveCounts(readLive(ctx, now), p.session_id);
+  if (!tag.parallel_ok) {
+    const scope = lim.session > 0 && c.session >= lim.session ? 'session'
+      : (lim.machine > 0 && c.machine >= lim.machine ? 'machine' : null);
+    if (scope) {
+      const ev = logGate(ctx, p, `task:${tag.task_id}`, { task_id: tag.task_id, role: tag.role },
+        { gate_action: 'deny', reason_code: 'parallel-cap', cap_scope: scope, live_session: c.session, live_machine: c.machine });
+      return { denied: true, event: ev, stdout: preToolDeny(parallelDenyText(scope, c, lim, tag, now)) };
+    }
+  }
+  writeIntent(ctx, p, tag, { live_session: c.session, live_machine: c.machine });
+  if (lim.warn > 0 && c.machine + 1 >= lim.warn) {
+    return {
+      denied: false,
+      stdout: JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          additionalContext: `dieu-phoi: toàn máy sẽ có ${c.machine + 1} agent dieu-phoi chạy cùng lúc (cảnh báo từ ${lim.warn}, trần ${lim.machine || 'tắt'}); `
+            + `phiên này ${c.session + 1}/${lim.session || 'tắt'}. Máy chậm dần khi đông agent: ưu tiên chờ bớt trước khi giao tiếp.`,
+        },
+      }),
+    };
+  }
+  return null;
+}
+
+/** Counts + per-agent rows for doctor / state. */
+function liveSummary(ctx, sessionId, now) {
+  const t = typeof now === 'number' ? now : Date.now();
+  const c = liveCounts(readLive(ctx, t), sessionId);
+  return {
+    session: sessionId ? c.session : null,
+    machine: c.machine,
+    limits: parallelLimits(ctx),
+    agents: c.all.map((r) => ({
+      agent_id: r.agent_id || null, task_id: r.task_id || null, role: r.role || null, gen: Number(r.gen) || 1,
+      session: r.session_id ? sha8(r.session_id) : null, age_min: liveAgeMin(r, t), pending: !!r.pending,
+      idle_min: r.pending ? null : Math.max(0, Math.round((t - (liveMs(r.last_activity) || t)) / 60000)),
+    })),
+    labels: c.all.map((r) => liveLabel(r, t, true)),
+  };
+}
+
+/*
+ * Core 0.7.3 (s6): stuck / orphaned live agents. done/fail = SubagentStop (removeLive), so whatever is still in data/live
+ * is running, stuck, or orphaned (crashed without SubagentStop). Evidence per record: last_activity (--watch heartbeat),
+ * the subagent transcript mtime, the parent session transcript mtime, and a dp-out-/handoff- file of its task in the run
+ * dir. stuck = idle ≥ stuck_idle_min, OR running ≥ stuck_hard_min, OR its dp-out (STATUS) is on disk and it is still live
+ * stuck_after_status_min later (waiting on a background task). orphan = idle AND the parent session is silent too (or
+ * unknown) — the agent is almost certainly gone and its live file only holds a parallel-cap slot until LIVE_TTL_MS.
+ * The main session is reminded (UserPromptSubmit / PostToolUse(Agent)) to TaskStop + `dieu-phoi reap --yes`; an exec is
+ * reminded about its own helpers through --watch. Nothing here kills or deletes: `reap --yes` does (lib/commands.cjs).
+ */
+const STUCK_DEFAULTS = { stuck_idle_min: 20, stuck_hard_min: 120, stuck_after_status_min: 5 };
+/** One reminder per agent per this long (stored as stuck_notified in its live file). */
+const STUCK_REMIND_MS = 10 * 60 * 1000;
+
+/** Thresholds in minutes: env DIEU_PHOI_<KEY> → config.json → STUCK_DEFAULTS. Numbers ≥ 0; 0 turns that rule off. */
+function stuckLimits(ctx) {
+  const cfg = (ctx && ctx.config) || {};
+  const pick = (key) => {
+    for (const v of [process.env[`DIEU_PHOI_${key.toUpperCase()}`], cfg[key]]) {
+      if (v === undefined || v === null || v === '') continue;
+      const n = Number(v);
+      if (Number.isFinite(n) && n >= 0) return n;
+    }
+    return STUCK_DEFAULTS[key];
+  };
+  return { idle: pick('stuck_idle_min'), hard: pick('stuck_hard_min'), after_status: pick('stuck_after_status_min') };
+}
+
+function mtimeMs(f) {
+  if (typeof f !== 'string' || !f) return null;
+  try { return fs.statSync(f).mtimeMs; } catch (_) { return null; }
+}
+
+/** Newest dp-out-<task>-* / handoff-<task>* .md in the run dir written after the agent started, else null. */
+function statusFileOf(rec, startMs) {
+  if (!rec.run_dir || !rec.task_id) return null;
+  const t = safeName(rec.task_id);
+  let names = [];
+  try { names = fs.readdirSync(rec.run_dir); } catch (_) { return null; }
+  let best = null;
+  for (const n of names) {
+    if (!n.endsWith('.md') || !(n.startsWith(`dp-out-${t}-`) || n.startsWith(`handoff-${t}`))) continue;
+    if (rec.role && n.startsWith(`dp-out-${t}-`) && !n.startsWith(`dp-out-${t}-${rec.role}`)) continue; // exec vs verify of one task
+    const m = mtimeMs(path.join(rec.run_dir, n));
+    if (m !== null && m >= (startMs || 0) - 1000 && (!best || m > best.mtime)) best = { file: path.join(rec.run_dir, n), mtime: m };
+  }
+  return best;
+}
+
+/** Verdict on one live record: { state: ok|stuck|orphan, reasons[], idle_min, age_min, … }. Never throws. */
+function assessLive(rec, now, lim) {
+  const startMs = liveMs(rec.start) || liveMs(rec.t) || now;
+  const tMtime = mtimeMs(rec.transcript);
+  const last = Math.max(liveMs(rec.last_activity) || 0, startMs, tMtime || 0);
+  const idleMin = Math.max(0, (now - last) / 60000);
+  const ageMin = Math.max(0, (now - startMs) / 60000);
+  const reasons = [];
+  if (lim.idle > 0 && idleMin >= lim.idle) reasons.push('idle');
+  if (lim.hard > 0 && ageMin >= lim.hard) reasons.push('hard');
+  const status = lim.after_status > 0 ? statusFileOf(rec, startMs) : null;
+  if (status && (now - status.mtime) / 60000 >= lim.after_status) reasons.push('after-status');
+  let state = reasons.length ? 'stuck' : 'ok';
+  if (reasons.includes('idle')) {
+    const sMtime = mtimeMs(rec.session_transcript);
+    if (sMtime === null || (now - sMtime) / 60000 >= lim.idle) state = 'orphan';
+  }
+  return {
+    agent_id: rec.agent_id || null, task_id: rec.task_id || null, role: rec.role || null, gen: Number(rec.gen) || 1,
+    parent_task_id: rec.parent_task_id || null, session_id: rec.session_id || null, cwd: rec.cwd || null,
+    start_ms: startMs, idle_min: Math.round(idleMin), age_min: Math.round(ageMin), reasons, state,
+    transcript_seen: tMtime !== null, status_file: status ? status.file : null,
+    status_min: status ? Math.round((now - status.mtime) / 60000) : null, notified: liveMs(rec.stuck_notified),
+  };
+}
+
+/** Stuck + orphaned live agents (oldest first). `sessionId` filters to one session, `parentTask` to one exec's helpers. */
+function stuckAgents(ctx, o) {
+  const opt = o || {};
+  const now = typeof opt.now === 'number' ? opt.now : Date.now();
+  const lim = opt.limits || stuckLimits(ctx);
+  const out = [];
+  for (const rec of readLive(ctx, now).agents) {
+    if (opt.sessionId && rec.session_id !== opt.sessionId) continue;
+    if (opt.parentTask && rec.parent_task_id !== opt.parentTask) continue;
+    const a = assessLive(rec, now, lim);
+    if (a.state !== 'ok') out.push(a);
+  }
+  return out.sort((a, b) => a.start_ms - b.start_ms);
+}
+
+const STUCK_REASON_TEXT = { idle: 'im lặng', hard: 'chạy quá lâu', 'after-status': 'đã có dp-out/STATUS mà chưa dừng' };
+
+function stuckReasonText(a) {
+  const bits = a.reasons.map((r) => (r === 'after-status' && a.status_min !== null ? `${STUCK_REASON_TEXT[r]} ${a.status_min} phút` : STUCK_REASON_TEXT[r] || r));
+  if (a.state === 'orphan') bits.push('có vẻ mồ côi — phiên cũng im');
+  return bits.join(', ');
+}
+
+/** One reminder line per agent: what is stuck and the exact next step. */
+function stuckLine(a, forExec) {
+  const who = `agent ${a.agent_id} task ${a.task_id || '?'} (${a.role || '?'}${a.gen > 1 ? `, gen ${a.gen}` : ''})`;
+  const n = a.reasons.includes('idle') ? a.idle_min : a.age_min;
+  const wt = a.cwd ? ` Worktree ${toPosix(a.cwd)} giữ nguyên (còn công việc).` : '';
+  const stop = !forExec && a.gen > 1 && a.parent_task_id
+    ? `helper của ${a.parent_task_id}: TaskStop ${a.agent_id} (hoặc nhắc exec cha dừng nó)`
+    : `TaskStop ${a.agent_id}`;
+  return `dieu-phoi: ${who} kẹt ${n} phút [${stuckReasonText(a)}] → ${stop}; xong rồi \`dieu-phoi reap --yes\` (xem trước: \`dieu-phoi reap\`).${wt}`;
+}
+
+/**
+ * Reminder text for stuck agents not reminded in the last STUCK_REMIND_MS, or null. Marks them (stuck_notified) so a
+ * busy session is not told the same thing on every prompt. Never throws.
+ */
+function stuckReminder(ctx, o) {
+  try {
+    const opt = o || {};
+    const now = typeof opt.now === 'number' ? opt.now : Date.now();
+    const due = stuckAgents(ctx, Object.assign({}, opt, { now })).filter((a) => !(a.notified && now - a.notified < STUCK_REMIND_MS));
+    if (!due.length) return null;
+    for (const a of due) {
+      const f = liveFile(ctx, a.agent_id);
+      const rec = readJsonFile(f, null);
+      if (rec && typeof rec === 'object') { rec.stuck_notified = new Date(now).toISOString(); try { writeFileAtomic(f, `${JSON.stringify(rec)}\n`); } catch (_) { /* best effort */ } }
+    }
+    return due.slice(0, 6).map((a) => stuckLine(a, !!opt.parentTask)).join('\n') + (due.length > 6 ? `\n(+${due.length - 6} agent kẹt khác: \`dieu-phoi reap\`)` : '');
+  } catch (e) {
+    logError(ctx.home, e, 'stuck-remind');
+    return null;
+  }
+}
+
 /**
  * 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
@@ -3488,7 +4564,23 @@ 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;
+  let r = null;
+  if (tag.role === 'verify') r = verifyOrphanGate(p, ctx, tag);
+  else if (tag.role === 'exec') r = (tag.chain_ok ? null : chainGateDenial(p, ctx, tag)) || sessionCapGate(p, ctx, tag);
+  if (r) return r;
+  // core 0.7.3 (s1): parallel cap last, so a dispatch another gate denies never leaves an intent behind
+  return LIVE_SESSION_ROLES.includes(tag.role) ? parallelCapGate(p, ctx, tag) : null;
+}
+
+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 +4588,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ẻ.'),
   };
 }
 
@@ -3567,6 +4709,12 @@ function handleGate(p, ctx) {
     }),
   });
   if (why.length) return deny(why, codes.join('+'));
+  // core 0.7.3 (s1): helpers count towards the machine cap
+  const lim = parallelLimits(ctx);
+  const lc = liveCounts(readLive(ctx), p.session_id);
+  if (!tag.parallel_ok && lim.machine > 0 && lc.machine >= lim.machine) {
+    return deny([`toàn máy đã có ${lc.machine}/${lim.machine} agent dieu-phoi đang chạy (trần max_parallel_machine) — tự làm phần này, đừng giao helper`], 'parallel-cap');
+  }
   const root = path.join(ctx.paths.data, 'gate');
   fs.mkdirSync(root, { recursive: true });
   pruneGate(root);
@@ -3574,6 +4722,13 @@ function handleGate(p, ctx) {
   const slot = gateReserve(dir, tag.task_id);
   if (!slot) return deny([`đã giao đủ ${GATE_MAX_CHILDREN} helper cho bước này — tự làm phần còn lại`], 'max-children');
   const children = gateSlots(dir).length;
+  const parentLive = readJsonFile(liveFile(ctx, agentId), null);
+  writeIntent(ctx, p, tag, {
+    gen: (parentLive && Number(parentLive.gen) ? Number(parentLive.gen) : 1) + 1,
+    parent_task_id: tag.parent_task_id || st.task_id || null,
+    worktree: (parentLive && parentLive.cwd) || null,
+    live_session: lc.session, live_machine: lc.machine,
+  });
   return { denied: false, slot, children, event: log('allow', { slot, children }) };
 }
 
@@ -3664,11 +4819,19 @@ 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 === 'PreToolUse') return handleChainGate(p, ctx); // { stdout } (deny / warn) or null
+    if (name === 'SubagentStart') return handleSubagentStart(p, ctx); // live record or null, prints nothing
     if (name === 'SessionStart') return handleSessionStart(p, ctx); // { stdout } or null, never an event
     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') {
+      // s7: keep the live record (worktree, start) for the guarded leftover kill before the file goes
+      let live = null;
+      try { live = typeof p.agent_id === 'string' && p.agent_id ? readJsonFile(liveFile(ctx, p.agent_id), null) : null; } catch (_) { live = null; }
+      try { removeLive(ctx, p.agent_id); } catch (e) { logError(home, e, 'live-remove'); }
+      const r = handleSubagentStop(p, ctx, { live });
+      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 +4981,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 +4991,14 @@ 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,
+  liveLoadCounts, appendLoadSample, loadFile, LIVE_TTL_MS, LIVE_TOUCH_MS, LIVE_PENDING_MS, PARALLEL_DEFAULTS, LIVE_SESSION_ROLES, AGENT_TYPE_ROLES, liveDir, liveFile, livePendingDir, intentFile, parallelLimits, readLive, liveCounts, liveSummary, briefWorktree, writeIntent, claimIntent, handleSubagentStart, removeLive, touchLive, dispatchLiveCounts, parallelCapGate,
+  STUCK_DEFAULTS, STUCK_REMIND_MS, stuckLimits, assessLive, stuckAgents, stuckReminder, stuckLine, stuckReasonText, statusFileOf, briefRunDir, liveTranscriptGuess,
+  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, mainShellSince, ownWorktree, maybeSpawnSync, runHook, runSync,
 };
 
 if (require.main === module) {