@kienntpixon/dieu-phoi 0.6.0 → 0.7.0

package/hook.cjs

@@ -26,7 +26,7 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 
-const CORE_VERSION = '0.6.0';
+const CORE_VERSION = '0.7.0';
 const SCHEMA = 1;
 const TASK_TYPES = [
   'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',
@@ -1118,6 +1118,9 @@ function buildSessionState(events, sessionId, opts) {
   for (const id of [...planOfRoot.keys(), ...stepOf.keys()]) {
     if (!seenTask.has(id) && !discarded.has(id)) { seenTask.add(id); taskIds.push(id); }
   }
+  const modeEvents = new Map();
+  for (const ev of events) if (ev && ev.kind === 'mode' && isMode(ev.mode) && typeof ev.root_task_id === 'string') modeEvents.set(ev.root_task_id, ev);
+  const modeOfRoot = (root) => (modeEvents.has(root) ? modeEvents.get(root).mode : DEFAULT_MODE);
   const per = new Map(taskIds.map((id) => [id, { dispatches: [], user: [], steers: [], overrides: [], agentIds: new Set() }]));
   events.forEach((ev, i) => {
     if (!ev || typeof ev !== 'object') return;
@@ -1168,6 +1171,7 @@ function buildSessionState(events, sessionId, opts) {
       const pApproved = pov && evMs(pov) > (Date.parse(ps.plan.approved_at) || 0) ? pov.chosen_tier || null : null;
       tasks.push(Object.assign({
         task_id: id, task_type: ps.step.type || null, gate: 2, pending: true, verify_only: false, round: 0,
+        mode: isMode(ps.step.mode) ? ps.step.mode : modeOfRoot(ps.plan.root_task_id),
       }, planInfo, {
         approved_tier: pApproved || ps.step.tier || null, last_tier: null, attempts: [], user_verdict: null, last_steer: null,
         run_dir: planDir, last_ts: null,
@@ -1225,6 +1229,7 @@ function buildSessionState(events, sessionId, opts) {
       pending: false,
       verify_only: attempts.length > 0 && attempts.every((a) => a.role === 'verify'),
       round,
+      mode: dispatchModeFromEvents(t.dispatches, id) || (ps && isMode(ps.step.mode) ? ps.step.mode : modeOfRoot(plan ? plan.root_task_id : id)),
     }, planInfo, {
       approved_tier: approved,
       last_tier: lastExecAny ? tierOf(lastExecAny.model, lastExecAny.effort) : null,
@@ -1235,10 +1240,26 @@ function buildSessionState(events, sessionId, opts) {
       last_ts: lastMs ? new Date(lastMs).toISOString() : null,
     }));
   }
+  // modes of the roots this session works on: plan roots, tasks' own roots, and roots whose mode event was written here
+  const sidHash = sha8(sessionId);
+  const modeRoots = new Set(plans.map((p) => p.root_task_id));
+  for (const id of taskIds) if (modeEvents.has(id)) modeRoots.add(id);
+  for (const [root, ev] of modeEvents) if (ev.session_id === sessionId || ev.session === sidHash) modeRoots.add(root);
+  const modes = Array.from(modeRoots).map((root) => {
+    const ev = modeEvents.get(root);
+    const mode = ev ? ev.mode : DEFAULT_MODE;
+    // core 0.7.0 (s2): suggestion only — the mode itself never changes here
+    const sug = modeSuggestion(events, root, { mode, taskIds: rootTaskIds(allPlans, root) });
+    return {
+      root_task_id: root, mode, since: ev ? ev.ts : null, source: ev ? ev.source || null : 'default', reason_code: ev ? ev.reason_code || null : null,
+      mode_suggest: sug.mode_suggest, mode_suggest_reason: sug.mode_suggest_reason,
+    };
+  });
   return {
     session_id: sessionId,
     generated_at: nowIso(),
     runs_dir: `${runs}/`,
+    modes,
     plans: plans.map((p) => ({
       root_task_id: p.root_task_id,
       approval: Number.isInteger(p.approval) ? p.approval : (Number.isInteger(p.round) ? p.round : null),
@@ -1268,7 +1289,8 @@ function taskLines(t) {
     + `${t.round ? ` · vòng ${t.round}` : ''}${t.approved_tier ? ` · duyệt ${t.approved_tier}` : ''}`
     + `${t.last_tier && t.last_tier !== t.approved_tier ? ` · tier cuối ${t.last_tier}` : ''}`
     + `${t.user_verdict ? ` · người dùng: ${t.user_verdict.outcome}${t.user_verdict.cause ? `/${t.user_verdict.cause}` : ''}` : ''}`
-    + `${t.last_steer ? ` · steer: ${t.last_steer}` : ''}`;
+    + `${t.last_steer ? ` · steer: ${t.last_steer}` : ''}`
+    + `${t.mode && t.mode !== DEFAULT_MODE ? ` · mode ${t.mode}` : ''}`;
   const att = t.attempts.map((a) => `${a.agent_id} ${a.role}${a.try ? ` try${a.try}` : ''} ${tierOf(a.model, a.effort) || '?'} ${a.status}`);
   const out = [head];
   if (att.length) out.push(`${indent}    ${att.join(' | ')}`);
@@ -1310,11 +1332,26 @@ function compactSystemMessage(state) {
   return `dieu-phoi: đã nạp lại trạng thái điều phối sau khi nén (${c.tasks} task, ${c.running} agent đang chạy, ${c.pending} bước chưa giao)`;
 }
 
+/** "\nMode: <root>=<mode> …" for the roots of a session (last 6); '' when the state carries none. */
+function modesLine(state) {
+  const ms = Array.isArray(state.modes) ? state.modes : [];
+  if (!ms.length) return '';
+  const sug = ms.slice(-6).filter((m) => m.mode_suggest).map((m) => `\n${modeSuggestLine(m.root_task_id, m.mode, m.mode_suggest_reason)}`).join('');
+  return `\nMode (theo yêu cầu, đổi bằng \`dieu-phoi mode --root <id> <mode>\`): ${ms.slice(-6).map((m) => `${m.root_task_id}=${m.mode}`).join(', ')}.${sug}`;
+}
+
+/** One line telling the orchestrator to ASK the user about returning to normal (never switch by itself). */
+function modeSuggestLine(root, mode, reason) {
+  return `GỢI Ý mode: ${root ? `${root} đang ${mode}` : `đang ${mode}`} — hỏi người dùng có muốn quay về normal không (${reason}); `
+    + `chỉ đổi khi người dùng đồng ý: \`dieu-phoi mode --root ${root || '<root>'} normal\`. KHÔNG tự đổi mode.`;
+}
+
 function formatSessionState(state, cap) {
   const limit = cap || STATE_TEXT_CAP;
   const { open, pending, running } = stateCounts(state);
   const header = `Phiên ${state.session_id}: ${state.tasks.length} task (${open.length} chưa xong, ${pending} bước chưa giao, ${running} agent đang chạy). `
-    + `Thư mục chạy: ${state.runs_dir} (chỉ trỏ tới, không tự đọc).`;
+    + `Thư mục chạy: ${state.runs_dir} (chỉ trỏ tới, không tự đọc).`
+    + modesLine(state);
   if (!state.tasks.length) return `${header}\nChưa có task nào được giao trong phiên này.`;
   const byAge = (a, b) => String(a.last_ts || '').localeCompare(String(b.last_ts || ''));
   const dropOrder = state.tasks.filter((t) => t.gate === 'done').sort(byAge)
@@ -1397,7 +1434,8 @@ function sinkStatusCached(ctx, nowMs) {
   const now = nowMs || Date.now();
   const cands = [];
   const chk = readJsonFile(ctx.paths.sinkCheck, null);
-  if (chk && chk.url === sinkUrlKey(cfg) && Date.parse(chk.ts)) {
+  // a timed-out doctor check (`timeout: true`) is "slow/unknown", not a failure: ignored here, so a fresher sync result or `unknown` wins
+  if (chk && !chk.timeout && chk.url === sinkUrlKey(cfg) && Date.parse(chk.ts)) {
     cands.push({ state: chk.ok ? 'ok' : 'fail', ts: chk.ts, source: 'doctor', detail: chk.detail || null });
   }
   const ls = readJsonFile(ctx.paths.lastSync, null);
@@ -1502,7 +1540,7 @@ function startInfo(ctx, cwd) {
   const run = startRun();
   const health = quickHealth(ctx, run.runs);
   const info = {
-    id: run.id, run_dir: run.run_dir, step_ids: stepIds(run.id, START_STEP_IDS), health, scout_brief: scoutBriefPath(ctx),
+    id: run.id, run_dir: run.run_dir, step_ids: stepIds(run.id, START_STEP_IDS), health, scout_brief: scoutBriefPath(ctx), mode: null,
     orch_lessons: orchLessons(ctx),
   };
   const k = startKnowledgeOf(cwd);
@@ -1519,6 +1557,11 @@ function orchLessonLines(info) {
   return ls.length ? ['bài học cho điều phối viên (profile/lessons.md, [orch]):'].concat(ls.map((l) => `  - ${l}`)) : [];
 }
 
+/** Gate-1 mode line: the chosen mode, or the reminder to ASK the user (default normal). */
+function modeLine(info) {
+  return info && isMode(info.mode) ? `mode: ${info.mode} (đã ghi cho root ${info.id}; đổi: dieu-phoi mode --root ${info.id} <mode>)` : MODE_ASK_LINE;
+}
+
 function formatStartBlock(info) {
   return [
     START_PREFIX,
@@ -1527,6 +1570,7 @@ function formatStartBlock(info) {
     `step_ids: ${info.step_ids.join(' ')}`,
     `health: ${healthLine(info.health)}`,
     `scout_brief: ${info.scout_brief || '(không thấy — dùng references/brief-template.md mục E)'}`,
+    modeLine(info),
     ...orchLessonLines(info),
     ...knowledgeLines(info),
     'Dùng khối này cho yêu cầu MỚI ở cổng 1 (không dùng nếu đang giữa một lần điều phối). Không chạy `dieu-phoi doctor` / `new-id` / mkdir: lượt đầu tiên là Agent scout + câu hỏi cổng 1 cho người dùng.',
@@ -1651,7 +1695,204 @@ 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\`).`;
 }
 
-// ------------------------------------------------------------------ core 0.6.0 (unreleased): project identity
+// ------------------------------------------------------------------ core 0.7.0: mode per request (fast | normal | strict)
+//
+// A request (root_task_id) has a mode; the user picks it at gate 1 (`start --mode`, `plan-table` file, or
+// `dieu-phoi mode --root R <mode>` at any time). Every change is one local-only event kind=mode. A step not yet
+// dispatched follows the root's current mode (or its own `mode` override in the approved plan); a step already
+// dispatched keeps the mode its first exec dispatch recorded. Nothing here ever changes a mode by itself.
+
+const MODES = ['fast', 'normal', 'strict'];
+const DEFAULT_MODE = 'normal';
+/** Event kinds that stay on this machine: runSync does not send them (an older sink would answer bad_kind). */
+const LOCAL_ONLY_KINDS = new Set(['mode']);
+const MODE_ASK_LINE = 'mode: HỎI người dùng chọn mode cho yêu cầu này — fast (bỏ verifier riêng ở bước s≤6, test chọn lọc, '
+  + 'một verifier gộp) | normal | strict (mặc định normal nếu không trả lời); đặt bằng `dieu-phoi mode --root <root_task_id> <mode>`';
+
+function isMode(m) {
+  return typeof m === 'string' && MODES.includes(m);
+}
+
+/** Last mode event of `root` in an events array (null when none). */
+function rootModeFromEvents(events, root) {
+  let last = null;
+  for (const ev of events) {
+    if (ev && ev.kind === 'mode' && ev.root_task_id === root && isMode(ev.mode)) last = ev;
+  }
+  return last;
+}
+
+/** Same, from the text of events.jsonl (hook hot path: substring scan, no full parse). */
+function rootModeFromText(txt, root) {
+  const needle = '"kind":"mode"';
+  const rootNeedle = `"root_task_id":${JSON.stringify(root)}`;
+  let last = null;
+  let i = txt.indexOf(needle);
+  while (i >= 0) {
+    const start = txt.lastIndexOf('\n', i) + 1;
+    const end = txt.indexOf('\n', i);
+    const line = txt.slice(start, end < 0 ? undefined : end);
+    if (line.includes(rootNeedle)) {
+      try {
+        const ev = JSON.parse(line);
+        if (ev && ev.kind === 'mode' && isMode(ev.mode)) last = ev;
+      } catch (_) { /* corrupt line */ }
+    }
+    i = end < 0 ? -1 : txt.indexOf(needle, end);
+  }
+  return last;
+}
+
+/** Mode the first exec dispatch of `taskId` recorded (a dispatched step keeps its mode), from an events array. */
+function dispatchModeFromEvents(events, taskId) {
+  for (const ev of events) {
+    if (ev && ev.kind === 'dispatch' && ev.task_id === taskId && (ev.role || 'exec') === 'exec' && isMode(ev.mode)) return ev.mode;
+  }
+  return null;
+}
+
+function dispatchModeFromText(txt, taskId) {
+  const needle = `"task_id":${JSON.stringify(taskId)}`;
+  let i = txt.indexOf(needle);
+  while (i >= 0) {
+    const start = txt.lastIndexOf('\n', i) + 1;
+    const end = txt.indexOf('\n', i);
+    const line = txt.slice(start, end < 0 ? undefined : end);
+    if (line.includes('"kind":"dispatch"') && !line.includes('"role":"verify"') && !line.includes('"role":"plan"') && !line.includes('"role":"helper"')) {
+      const m = /"mode":"(fast|normal|strict)"/.exec(line);
+      if (m) return m[1];
+    }
+    i = end < 0 ? -1 : txt.indexOf(needle, end);
+  }
+  return null;
+}
+
+/** Approved plan holding `taskId` as a step (or as its root): { root, step|null } or null. */
+function planOfTask(ctx, taskId) {
+  for (const p of loadPlans(ctx.paths.plans)) {
+    const step = p.steps.find((s) => s && s.task_id === taskId);
+    if (step) return { root: p.root_task_id, step };
+  }
+  for (const p of loadPlans(ctx.paths.plans)) if (p.root_task_id === taskId) return { root: taskId, step: null };
+  return null;
+}
+
+/**
+ * Mode a task runs in: its first exec dispatch (locked) > its step `mode` in the approved plan > the root's current
+ * mode event > normal. `events` (array) is for the CLI; without it the hook scans events.jsonl as text.
+ * Returns { mode, source: 'dispatched'|'step'|'root'|'default', root }.
+ */
+function taskModeInfo(ctx, taskId, events) {
+  let txt = null;
+  if (!events) { try { txt = fs.readFileSync(ctx.paths.events, 'utf8'); } catch (_) { txt = ''; } }
+  const pl = taskId ? planOfTask(ctx, taskId) : null;
+  const root = pl ? pl.root : (taskId || null);
+  if (taskId) {
+    const locked = events ? dispatchModeFromEvents(events, taskId) : dispatchModeFromText(txt, taskId);
+    if (locked) return { mode: locked, source: 'dispatched', root };
+  }
+  if (pl && pl.step && isMode(pl.step.mode)) return { mode: pl.step.mode, source: 'step', root };
+  if (root) {
+    const ev = events ? rootModeFromEvents(events, root) : rootModeFromText(txt, root);
+    if (ev) return { mode: ev.mode, source: 'root', root };
+  }
+  return { mode: DEFAULT_MODE, source: 'default', root };
+}
+
+// core 0.7.0 (s2): signals for SUGGESTING a return to normal. The CLI never switches the mode itself; only the
+// user's `dieu-phoi mode` does. A suggestion is computed only while the root is in fast.
+const FAST_FAIL_WINDOW = 10;     // last N fast exec steps (all roots, file order of their first exec dispatch)
+const FAST_FAIL_MIN_N = 5;       // fewer fast steps than this -> no rate signal yet
+const FAST_FAIL_RATE = 0.15;     // >= this share failed -> suggest normal
+const BATCH_VERIFY_RE = /^batch-verify(?:-|$)/;
+const QUOTA_VERDICT_RE = /^(?:quota-pause|usage-limit|auto-quota-pause|auto-usage-limit|paused-for-quota)(?:-|$)/;
+
+/** A user reject that counts as a quality signal (legacy `rework` too); scope rejects (request changed) do not. */
+function isQualityReject(ev) {
+  if (ev.outcome === 'rework' && !ev.by) return true;
+  return ev.by === 'user' && ev.outcome === 'reject' && ev.cause !== 'scope';
+}
+
+/** Agent-layer fail (fail / timeout, never a quota pause or aborted). */
+function isAgentFail(ev) {
+  if (ev.by === 'user' || ev.by === 'auto') return false;
+  if (ev.outcome === 'fail') return true;
+  return ev.outcome === 'timeout' && !QUOTA_VERDICT_RE.test(String(ev.reason_code || ''));
+}
+
+/**
+ * Fail rate over the last FAST_FAIL_WINDOW fast exec steps (any root): a step is a task whose first exec dispatch
+ * recorded mode=fast; it failed when it has an agent-layer fail or a quality reject. Discarded tasks are left out.
+ * Returns { n, failed, rate } (rate null when n = 0).
+ */
+function fastFailRate(events) {
+  const gone = new Set();
+  for (const ev of events) if (ev && ev.kind === 'discard' && typeof ev.task_id === 'string') gone.add(ev.task_id);
+  const order = [];
+  const seen = new Set();
+  for (const ev of events) {
+    if (!ev || ev.kind !== 'dispatch' || typeof ev.task_id !== 'string' || !ev.task_id) continue;
+    if ((ev.role || 'exec') !== 'exec' || seen.has(ev.task_id)) continue;
+    seen.add(ev.task_id);
+    if (ev.mode === 'fast' && !gone.has(ev.task_id)) order.push(ev.task_id);
+  }
+  const win = new Set(order.slice(-FAST_FAIL_WINDOW));
+  const failed = new Set();
+  for (const ev of events) {
+    if (ev && ev.kind === 'verdict' && win.has(ev.task_id) && (isAgentFail(ev) || isQualityReject(ev))) failed.add(ev.task_id);
+  }
+  return { n: win.size, failed: failed.size, rate: win.size ? failed.size / win.size : null };
+}
+
+/**
+ * Should the orchestrator SUGGEST (never apply) a return to normal for `root`? Only while `mode` (the root's current
+ * mode) is fast. Signals, each with a short Vietnamese reason:
+ *   - batch-verify: an agent verdict fail with reason batch-verify on a task of the root, after the root's last mode event;
+ *   - reject: a quality reject (user) on a task of the root, after that mode event;
+ *   - fail-rate: >= 15% failed among the last 10 fast steps (all roots; needs >= 5 steps).
+ * `taskIds` = the root and its plan's step task ids. Returns { mode_suggest: 'normal'|null, mode_suggest_reason,
+ * mode_suggest_signals[] }.
+ */
+function modeSuggestion(events, root, o) {
+  const opts = o || {};
+  const none = { mode_suggest: null, mode_suggest_reason: null, mode_suggest_signals: [] };
+  if (opts.mode !== 'fast') return none;
+  const ids = new Set(opts.taskIds || []);
+  if (root) ids.add(root);
+  const last = root ? rootModeFromEvents(events, root) : null;
+  const since = last ? (Date.parse(last.ts) || 0) : 0;
+  const signals = [];
+  const reasons = [];
+  let batch = null;
+  let reject = null;
+  for (const ev of events) {
+    if (!ev || ev.kind !== 'verdict' || !ids.has(ev.task_id)) continue;
+    const t = Date.parse(ev.ts) || 0;
+    if (t < since) continue;
+    if (!batch && ev.outcome === 'fail' && BATCH_VERIFY_RE.test(String(ev.reason_code || ''))) batch = ev.task_id;
+    if (!reject && isQualityReject(ev)) reject = ev.task_id;
+  }
+  if (batch) { signals.push('batch-verify'); reasons.push(`verifier gộp báo fail (task ${batch})`); }
+  if (reject) { signals.push('reject'); reasons.push(`người dùng reject (task ${reject})`); }
+  const fr = fastFailRate(events);
+  if (fr.n >= FAST_FAIL_MIN_N && fr.rate >= FAST_FAIL_RATE) {
+    signals.push('fail-rate');
+    reasons.push(`${fr.failed}/${fr.n} bước fast gần nhất fail (${Math.round(fr.rate * 100)}% ≥ ${Math.round(FAST_FAIL_RATE * 100)}%)`);
+  }
+  if (!signals.length) return none;
+  return { mode_suggest: 'normal', mode_suggest_reason: reasons.join('; '), mode_suggest_signals: signals };
+}
+
+/** Task ids of a root: the root itself plus the step task ids of its approved plan (if any). */
+function rootTaskIds(plans, root) {
+  const out = new Set(root ? [root] : []);
+  for (const p of plans || []) {
+    if (p && p.root_task_id === root) for (const s of p.steps || []) if (s && s.task_id) out.add(s.task_id);
+  }
+  return out;
+}
+
+// ------------------------------------------------------------------ core 0.6.0: project identity
 //
 // A project (= one git repo, however many worktrees/clones) gets a stable key so every session and worktree can
 // share one knowledge store (~/.dieu-phoi/projects/<name>-<sha8(key)>/). Everything here is plain file reads —
@@ -1912,7 +2153,7 @@ function readHead(start) {
   return sha ? { branch, sha, detached: false } : { branch, sha: null, detached: false, unborn: true };
 }
 
-// ------------------------------------------------------------------ core 0.6.0 (unreleased), s3: knowledge freshness
+// ------------------------------------------------------------------ core 0.6.0, s3: knowledge freshness
 //
 // A knowledge section is stale when a file matching its `paths` globs differs between the commit it was merged at
 // (`sha`) and the HEAD of the worktree asking. Used by the start block here and by `knowledge get/list/status`
@@ -2295,12 +2536,19 @@ function buildDispatch(p, ctx) {
     orch_cum_usd: orch.cum_usd,
   }, tag.parent_task_id ? { parent_task_id: tag.parent_task_id } : {},
   projectFields(p),
+  modeFields(ctx, tag),
   tierFields(ctx, tag, normalizeModel(trObj.resolvedModel) || normalizeModel(ti.model) || null, explicitEffort || parentEffort || null),
   // core 0.5.0: an Agent call made inside a subagent (gen-2) carries the caller's agent_id
   typeof p.agent_id === 'string' && p.agent_id ? { parent_agent_id: p.agent_id } : {},
   commonFields(ctx));
 }
 
+/** core 0.7.0: mode of the task at the moment of this dispatch (kept by later tries), only when the tag carries a task_id. */
+function modeFields(ctx, tag) {
+  if (!tag || !tag.task_id || !isValidTaskId(tag.task_id)) return {};
+  try { return { mode: taskModeInfo(ctx, tag.task_id).mode }; } catch (_) { return {}; }
+}
+
 /** suggested_tier / choose_tier / suggested_source / dispatched_tier / tier_mismatch, only when choose left a record. */
 function tierFields(ctx, tag, model, effort) {
   const s = tag.task_id ? readSuggestion(ctx, tag.task_id, tag.role) : null;
@@ -2547,6 +2795,16 @@ function handleSubagentStop(p, ctx) {
   }
   // exec/verify/plan only: true = it returned without writing its dp-out file (the hook saved the .inline.md)
   if (tag && RESULT_ROLES.includes(tag.role)) ev.inline_result = Boolean(inline);
+  // core 0.7.0 (s2): seconds spent running tests in this segment (transcript; else the dp-out `TEST_S:` line)
+  const tt = exists && sum ? testTimeOf(lines.slice(sum.segment_start)) : null;
+  ev.test_s = tt ? tt.test_s : null;
+  ev.test_runs = tt ? tt.test_runs : null;
+  ev.full_suite_runs = tt ? tt.full_suite_runs : null;
+  ev.test_s_source = ev.test_s !== null ? 'transcript' : null;
+  if (ev.test_s === null && exists && tag) {
+    const v = testSFromResultFile(lines, tag);
+    if (v !== null) { ev.test_s = v; ev.test_s_source = 'dp-out'; }
+  }
   // Record the segment before appending so a racing duplicate fire sees it.
   if (sum && sum.last_uuid) {
     saveSegments(ctx, agentId, {
@@ -2629,6 +2887,134 @@ function completionStatus(text, abortWhy) {
   return 'none';
 }
 
+// ------------------------------------------------------------------ core 0.7.0 (s2): time spent running tests
+//
+// Measured at SubagentStop from the subagent transcript: every Bash/PowerShell tool_use whose command runs tests is
+// paired with its tool_result line; test_s = sum of (result timestamp - tool_use timestamp). This is the same span a
+// PreToolUse/PostToolUse(Bash) pair would give, without registering hooks on every Bash call of every session (the
+// dp-* agents only hook PostToolUse, which carries no start time). Backgrounded commands return at once, so they are
+// counted (test_runs) but not timed. Nothing timed -> fall back to the `TEST_S:` line of the agent's dp-out file.
+
+const TEST_TOOL_NAMES = new Set(['Bash', 'PowerShell']);
+const PKG_RUNNERS = new Set(['npm', 'pnpm', 'yarn', 'bun']);
+const TEST_FILE_RE = /\.(?:test|spec)\.[cm]?[jt]sx?$|(?:^|[\\/])tests?[\\/][^\s]*\.[cm]?[jt]sx?$/;
+
+/** Positional args (not flags) of a token list. */
+function positionals(toks) {
+  return toks.filter((t) => t && !t.startsWith('-'));
+}
+
+/** One command segment (no && ; |) -> null (not a test run) or { full } (full = whole suite, no file/filter args). */
+function testSegmentInfo(seg) {
+  let s = ` ${seg} `.replace(/\s\d?>>?&?\s*[^\s]+/g, ' ').trim();
+  for (let k = 0; k < 6; k++) {
+    const n = s.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=[^\s]*\s+|time\s+|env\s+|rtk\s+(?:bypass\s+)?|timeout\s+[0-9]+[a-z]*\s+|npx\s+(?:--yes\s+|-y\s+)?|&\s*)/, '');
+    if (n === s) break;
+    s = n;
+  }
+  const toks = s.split(/\s+/).filter(Boolean).map((t) => t.replace(/^["']|["']$/g, ''));
+  if (!toks.length) return null;
+  const head = toks[0].replace(/\.(?:cmd|exe)$/i, '').split(/[\\/]/).pop();
+  if (PKG_RUNNERS.has(head)) {
+    let i = 1;
+    if (toks[i] === 'run' || toks[i] === 'run-script') i++;
+    const script = toks[i] || '';
+    if (script !== 'test' && script !== 't' && !/^test:/.test(script)) return null;
+    // `npm test` alone = the whole suite; a `test:<x>` script or extra args (`npm test -- file`) = a subset
+    return { full: (script === 'test' || script === 't') && positionals(toks.slice(i + 1)).length === 0 };
+  }
+  if (head === 'node') {
+    if (toks.includes('--test')) return { full: !positionals(toks.slice(1)).some((t) => /\.[cm]?[jt]sx?$/.test(t)) };
+    const file = positionals(toks.slice(1))[0] || '';
+    return TEST_FILE_RE.test(file) ? { full: false } : null;
+  }
+  if (head === 'pytest' || head === 'py.test') return { full: positionals(toks.slice(1)).length === 0 };
+  if (/^python[0-9.]*$|^py$/.test(head) && toks[1] === '-m' && toks[2] === 'pytest') return { full: positionals(toks.slice(3)).length === 0 };
+  if (head === 'jest') return { full: positionals(toks.slice(1)).length === 0 };
+  if (head === 'vitest') {
+    const rest = toks.slice(1);
+    if (rest[0] === 'run') rest.shift();
+    return { full: positionals(rest).length === 0 };
+  }
+  if (head === 'go' && toks[1] === 'test') return { full: toks.slice(2).includes('./...') };
+  if ((head === 'cargo' || head === 'dotnet') && toks[1] === 'test') return { full: positionals(toks.slice(2)).length === 0 };
+  return null;
+}
+
+/** A shell command -> null (runs no tests) or { full } (true when any test segment runs a whole suite). */
+function testCommandInfo(cmd) {
+  if (typeof cmd !== 'string' || !cmd.trim()) return null;
+  let hit = null;
+  for (const seg of cmd.split(/&&|\|\||;|\||\r?\n/)) {
+    const t = seg.trim();
+    if (!t) continue;
+    const info = testSegmentInfo(t);
+    if (info) hit = { full: Boolean((hit && hit.full) || info.full) };
+  }
+  return hit;
+}
+
+/**
+ * Test runs in transcript lines (one segment). Returns { test_s, test_runs, full_suite_runs }: test_s = seconds summed
+ * over the timed (foreground, with a result) test commands, null when none was timed; counts include backgrounded runs.
+ */
+function testTimeOf(lines) {
+  const open = new Map();
+  let runs = 0;
+  let full = 0;
+  let timed = 0;
+  let ms = 0;
+  for (const l of lines || []) {
+    if (!l || typeof l !== 'object' || !l.message || !Array.isArray(l.message.content)) continue;
+    const t = typeof l.timestamp === 'string' ? Date.parse(l.timestamp) : NaN;
+    if (l.type === 'assistant') {
+      for (const b of l.message.content) {
+        if (!b || b.type !== 'tool_use' || !TEST_TOOL_NAMES.has(b.name) || !b.input) continue;
+        const info = testCommandInfo(b.input.command);
+        if (!info) continue;
+        runs++;
+        if (info.full) full++;
+        if (b.id && b.input.run_in_background !== true && !isNaN(t)) open.set(b.id, t);
+      }
+    } else if (l.type === 'user') {
+      for (const b of l.message.content) {
+        if (!b || b.type !== 'tool_result' || !open.has(b.tool_use_id)) continue;
+        const t0 = open.get(b.tool_use_id);
+        open.delete(b.tool_use_id);
+        if (!isNaN(t) && t >= t0) { ms += t - t0; timed++; }
+      }
+    }
+  }
+  return { test_s: timed ? Math.round(ms / 100) / 10 : null, test_runs: runs, full_suite_runs: full };
+}
+
+/** Seconds from a `TEST_S: <n>[s|m|phút]` line of a result file's text (first 200 lines), or null. */
+function testSFromText(text) {
+  const head = String(text || '').split(/\r?\n/).slice(0, 200);
+  for (const raw of head) {
+    const m = /^[\s>*_`#-]*TEST_S\s*[*_`]*\s*[:=]\s*[*_`~≈]*\s*([0-9]+(?:[.,][0-9]+)?)\s*(giây|phút|ph|min|m|s)?\b/i.exec(raw);
+    if (!m) continue;
+    const n = Number(m[1].replace(',', '.'));
+    if (!isFinite(n) || n < 0) return null;
+    const unit = (m[2] || 's').toLowerCase();
+    return Math.round((unit === 's' || unit === 'giây' ? n : n * 60) * 10) / 10;
+  }
+  return null;
+}
+
+/** test_s from the agent's dp-out file(s) for (task, role, try) in the run dir its brief names, or null. Never throws. */
+function testSFromResultFile(lines, tag) {
+  try {
+    if (!tag || !RESULT_ROLES.includes(tag.role) || !tag.task_id) return null;
+    const dir = resultRunDir(firstPromptText(lines), tag.task_id);
+    for (const f of findResultFiles(dir, tag.task_id, tag.role, tag.try)) {
+      const v = testSFromText(readTextFile(f));
+      if (v !== null) return v;
+    }
+  } catch (_) { /* best effort */ }
+  return null;
+}
+
 // ------------------------------------------------------------------ core 0.5.0: context watchdog + gen-2 gate
 //
 // Both run only from the hooks of the dp-* agent files (~/.claude/agents, installed by `dieu-phoi setup`), so a session
@@ -3174,7 +3560,7 @@ async function runSync(ctx, opts) {
       for (const l of batch) {
         try {
           const r = JSON.parse(l.text);
-          if (r && typeof r === 'object' && !Array.isArray(r)) {
+          if (r && typeof r === 'object' && !Array.isArray(r) && !LOCAL_ONLY_KINDS.has(r.kind)) {
             delete r.synced;
             records.push(r);
           }
@@ -3211,6 +3597,9 @@ async function runSync(ctx, opts) {
 
 module.exports = {
   runsDir, loadPlans, isDieuPhoiPrompt, foldPrompt, sinkStatusCached, sinkUrlKey, SINK_CACHE_TTL_MS, scoutBriefPath, quickHealth, startRun, startInfo, startKnowledgeOf, knowledgeLines, orchLessons, orchLessonLines, abortReasonOf, completionStatus, logGate, QUOTA_PAUSE_MARKER, stepIds, START_STEP_IDS, healthLine, formatStartBlock, handleUserPromptSubmit, START_PREFIX, buildSessionState, formatSessionState, stateCounts, compactSystemMessage, handleSessionStart, dispatchInSession, STATE_TEXT_CAP, COMPACT_PREFIX,
+  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,
   sha8, nowIso, readJsonFile, writeFileAtomic, renameWithRetry, acquireLock, acquireFileLock, withFileLock, defaultClaudeDir, resolveHome, pathsFor, loadConfig, makeCtx,
   logError, computeUserHash, userHash, commonFields, parseTag, resolveTag, knownTaskTypes, tagIssueMessage, DEFAULT_EXTRA_TYPES,