@kienntpixon/dieu-phoi 0.0.0-stage → 0.1.0

package/hook.cjs

@@ -0,0 +1,834 @@
+#!/usr/bin/env node
+'use strict';
+/*
+ * dieu-phoi hook + core helpers.
+ *
+ * This file is copied verbatim to ~/.claude/dieu-phoi/bin/hook.cjs by `dieu-phoi setup`
+ * and run by Claude Code on PostToolUse(Agent) and SubagentStop. It must stay
+ * self-contained: Node built-ins only, no requires of other package files.
+ *
+ * Hook rules: never write to stdout, always exit 0, no synchronous network.
+ * Errors go to <home>/hook-errors.log.
+ *
+ *   node hook.cjs            -> read hook payload from stdin, append event
+ *   node hook.cjs --sync     -> push unsynced events to the sink (spawned detached)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const CORE_VERSION = '0.1.0';
+const SCHEMA = 1;
+const TASK_TYPES = [
+  'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',
+  'test-write', 'review', 'research-synth', 'content-write', 'plan-design', 'data-analysis',
+];
+const URGENCIES = ['relaxed', 'normal', 'urgent'];
+const ROLES = ['exec', 'verify', 'plan'];
+const MODEL_ALIASES = {
+  opus: 'claude-opus-5-5',
+  sonnet: 'claude-sonnet-5-5',
+  haiku: 'claude-haiku-5-5',
+  fable: 'claude-fable-5-5',
+};
+const SYNC_SPAWN_INTERVAL_MS = 10 * 60 * 1000;
+const MAX_ERRLOG_BYTES = 512 * 1024;
+
+// ------------------------------------------------------------------ basics
+
+function sha8(s) {
+  return crypto.createHash('sha256').update(String(s)).digest('hex').slice(0, 8);
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function sleepSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch (_) { /* ignore */ }
+}
+
+function readJsonFile(file, fallback) {
+  try {
+    const txt = fs.readFileSync(file, 'utf8').replace(/^/, '');
+    return JSON.parse(txt);
+  } catch (_) {
+    return fallback;
+  }
+}
+
+function renameWithRetry(from, to) {
+  let lastErr;
+  for (let i = 0; i < 8; i++) {
+    try {
+      fs.renameSync(from, to);
+      return;
+    } catch (e) {
+      lastErr = e;
+      if (!['EPERM', 'EBUSY', 'EACCES'].includes(e.code)) break;
+      sleepSync(25 * (i + 1));
+    }
+  }
+  try { fs.unlinkSync(from); } catch (_) { /* ignore */ }
+  throw lastErr;
+}
+
+/** Write a file atomically (tmp + rename), LF only. */
+function writeFileAtomic(file, content, mode) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}-${crypto.randomBytes(3).toString('hex')}`;
+  fs.writeFileSync(tmp, content, mode ? { mode } : undefined);
+  renameWithRetry(tmp, file);
+}
+
+// ------------------------------------------------------------------ paths / config
+
+/** Claude config dir: CLAUDE_CONFIG_DIR, else ~/.claude. */
+function defaultClaudeDir() {
+  if (process.env.CLAUDE_CONFIG_DIR) return path.resolve(process.env.CLAUDE_CONFIG_DIR);
+  return path.join(os.homedir(), '.claude');
+}
+
+/**
+ * Data home (normally ~/.claude/dieu-phoi). Order: explicit arg, DIEU_PHOI_HOME,
+ * DIEU_PHOI_CLAUDE_DIR, installed layout (<home>/bin/hook.cjs), CLAUDE_CONFIG_DIR, ~/.claude.
+ */
+function resolveHome(explicit) {
+  if (explicit) return path.resolve(explicit);
+  if (process.env.DIEU_PHOI_HOME) return path.resolve(process.env.DIEU_PHOI_HOME);
+  if (process.env.DIEU_PHOI_CLAUDE_DIR) {
+    return path.join(path.resolve(process.env.DIEU_PHOI_CLAUDE_DIR), 'dieu-phoi');
+  }
+  const here = __dirname;
+  if (path.basename(here) === 'bin' && path.basename(path.dirname(here)) === 'dieu-phoi') {
+    return path.dirname(here);
+  }
+  return path.join(defaultClaudeDir(), 'dieu-phoi');
+}
+
+function pathsFor(home) {
+  const data = path.join(home, 'data');
+  return {
+    home,
+    bin: path.join(home, 'bin'),
+    hook: path.join(home, 'bin', 'hook.cjs'),
+    data,
+    events: path.join(data, 'events.jsonl'),
+    segments: path.join(data, 'segments'),
+    syncOffset: path.join(data, 'sync-offset.json'),
+    syncSpawn: path.join(data, 'sync-spawn.json'),
+    lastSync: path.join(data, 'last-sync.json'),
+    syncRejected: path.join(data, 'sync-rejected.jsonl'),
+    lock: path.join(data, 'sync.lock'),
+    config: path.join(home, 'config.json'),
+    errlog: path.join(home, 'hook-errors.log'),
+  };
+}
+
+function loadConfig(home) {
+  const c = readJsonFile(pathsFor(home).config, {});
+  return c && typeof c === 'object' && !Array.isArray(c) ? c : {};
+}
+
+function makeCtx(home) {
+  const h = resolveHome(home);
+  const paths = pathsFor(h);
+  const config = loadConfig(h);
+  return { home: h, paths, config };
+}
+
+function logError(home, err, where) {
+  try {
+    const p = pathsFor(home || resolveHome());
+    fs.mkdirSync(p.home, { recursive: true });
+    try {
+      const st = fs.statSync(p.errlog);
+      if (st.size > MAX_ERRLOG_BYTES) fs.writeFileSync(p.errlog, '');
+    } catch (_) { /* no log yet */ }
+    const msg = err && err.stack ? err.stack : String(err);
+    fs.appendFileSync(p.errlog, `${nowIso()} [${where || 'hook'}] ${msg}\n`);
+  } catch (_) { /* nothing left to do */ }
+}
+
+// ------------------------------------------------------------------ identity
+
+function computeUserHash() {
+  let id = null;
+  try {
+    const cp = require('child_process');
+    const out = cp.execFileSync('git', ['config', '--get', 'user.email'], {
+      cwd: os.homedir(), timeout: 2000, windowsHide: true,
+      stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8',
+    });
+    if (out && out.trim()) id = out.trim().toLowerCase();
+  } catch (_) { /* git missing or unset */ }
+  if (!id) {
+    try { id = os.userInfo().username; } catch (_) { id = 'unknown'; }
+  }
+  return sha8(id);
+}
+
+function userHash(config) {
+  if (config && typeof config.user_hash === 'string' && /^[0-9a-f]{8}$/.test(config.user_hash)) {
+    return config.user_hash;
+  }
+  return computeUserHash();
+}
+
+function commonFields(ctx) {
+  const c = ctx.config || {};
+  return {
+    user: userHash(c),
+    dept: c.dept || null,
+    core_version: CORE_VERSION,
+    skill_version: c.skill_version || null,
+    synced: false,
+  };
+}
+
+// ------------------------------------------------------------------ tag
+
+const UNTAGGED = Object.freeze({
+  task_type: 'untagged', score: null, urgency: null, try: null, task_id: null, role: 'exec',
+});
+
+/** Parse `[dp:<type>|s<n>|<urgency>|try<n>|task=<id>|role=<r>]` from the first line. */
+function parseTag(text) {
+  if (typeof text !== 'string') return null;
+  const first = text.replace(/^/, '').split(/\r?\n/, 1)[0].trim();
+  const m = /^\[dp:([^\]]*)\]/.exec(first);
+  if (!m) return null;
+  const parts = m[1].split('|').map((s) => s.trim());
+  const type = (parts.shift() || '').toLowerCase();
+  if (!/^[a-z][a-z0-9-]{0,39}$/.test(type)) return null;
+  const tag = { task_type: type, score: null, urgency: null, try: null, task_id: null, role: 'exec' };
+  for (const p of parts) {
+    let mm;
+    if ((mm = /^s(\d{1,2})$/.exec(p))) {
+      const n = Number(mm[1]);
+      if (n <= 12) tag.score = n;
+    } else if (URGENCIES.includes(p)) {
+      tag.urgency = p;
+    } else if ((mm = /^try(\d{1,3})$/.exec(p))) {
+      tag.try = Number(mm[1]);
+    } else if ((mm = /^task=([A-Za-z0-9_-]{1,32})$/.exec(p))) {
+      tag.task_id = mm[1];
+    } else if ((mm = /^role=([a-z]+)$/.exec(p)) && ROLES.includes(mm[1])) {
+      tag.role = mm[1];
+    }
+  }
+  return tag;
+}
+
+// ------------------------------------------------------------------ models / pricing
+
+function normalizeModel(m) {
+  if (typeof m !== 'string' || !m) return null;
+  const s = m.trim().toLowerCase();
+  if (MODEL_ALIASES[s]) return MODEL_ALIASES[s];
+  return s;
+}
+
+function loadPricing(ctx) {
+  const candidates = [path.join(__dirname, 'pricing.json')];
+  if (ctx && ctx.paths) candidates.push(path.join(ctx.paths.bin, 'pricing.json'));
+  let base = null;
+  for (const f of candidates) {
+    base = readJsonFile(f, null);
+    if (base && base.models) break;
+  }
+  base = base && base.models ? base : { models: {}, cache_write_multipliers: { '5m': 1.25, '1h': 2 } };
+  const over = ctx && ctx.config && ctx.config.pricing;
+  return {
+    cache_write_multipliers: Object.assign({}, base.cache_write_multipliers,
+      over && over.cache_write_multipliers),
+    models: Object.assign({}, base.models, over && over.models),
+  };
+}
+
+/** Find the price entry for a model id: exact, else longest key the id starts with. */
+function priceFor(pricing, model) {
+  if (!pricing || !model) return null;
+  const id = normalizeModel(model);
+  if (pricing.models[id]) return pricing.models[id];
+  let best = null;
+  for (const k of Object.keys(pricing.models)) {
+    if (id.startsWith(k) && (!best || k.length > best.length)) best = k;
+  }
+  return best ? pricing.models[best] : null;
+}
+
+/** Split one API usage object into the event token buckets. */
+function usageBuckets(u) {
+  const n = (v) => (typeof v === 'number' && isFinite(v) ? v : 0);
+  const cc = n(u.cache_creation_input_tokens);
+  let cw5 = 0;
+  let cw1h = 0;
+  if (u.cache_creation && typeof u.cache_creation === 'object') {
+    cw5 = n(u.cache_creation.ephemeral_5m_input_tokens);
+    cw1h = n(u.cache_creation.ephemeral_1h_input_tokens);
+    const rest = cc - cw5 - cw1h;
+    if (rest > 0) cw5 += rest;
+  } else {
+    cw5 = cc;
+  }
+  return {
+    input: n(u.input_tokens),
+    output: n(u.output_tokens),
+    thinking: n(u.output_tokens_details && u.output_tokens_details.thinking_tokens),
+    cache_write_5m: cw5,
+    cache_write_1h: cw1h,
+    cache_read: n(u.cache_read_input_tokens),
+  };
+}
+
+/**
+ * Cost in USD of one API request. Thinking is already inside output_tokens.
+ * Returns null when the model has no price.
+ */
+function requestCost(pricing, model, b) {
+  const p = priceFor(pricing, model);
+  if (!p) return null;
+  const prompt = b.input + b.cache_write_5m + b.cache_write_1h + b.cache_read;
+  let inP = p.input;
+  let outP = p.output;
+  let crP = p.cache_read;
+  const lc = p.long_context;
+  if (lc && typeof lc.threshold_prompt_tokens === 'number' && prompt > lc.threshold_prompt_tokens) {
+    if (typeof lc.input === 'number') inP = lc.input;
+    if (typeof lc.output === 'number') outP = lc.output;
+    if (typeof lc.cache_read === 'number') crP = lc.cache_read;
+  }
+  const mult = pricing.cache_write_multipliers || {};
+  const m5 = typeof mult['5m'] === 'number' ? mult['5m'] : 1.25;
+  const m1h = typeof mult['1h'] === 'number' ? mult['1h'] : 2;
+  const usd = b.input * inP + b.cache_write_5m * inP * m5 + b.cache_write_1h * inP * m1h
+    + b.cache_read * crP + b.output * outP;
+  return usd / 1e6;
+}
+
+// ------------------------------------------------------------------ transcript
+
+function parseJsonl(text) {
+  const out = [];
+  for (const line of String(text).split('\n')) {
+    const t = line.trim();
+    if (!t) continue;
+    try { out.push(JSON.parse(t)); } catch (_) { /* skip torn line */ }
+  }
+  return out;
+}
+
+function readTranscript(file) {
+  return parseJsonl(fs.readFileSync(file, 'utf8'));
+}
+
+function lastUuidOf(lines) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i] && typeof lines[i].uuid === 'string') return lines[i].uuid;
+  }
+  return null;
+}
+
+/** Tag from the first user message of the transcript (the original prompt). */
+function tagFromTranscript(lines) {
+  for (const l of lines) {
+    if (!l || l.type !== 'user' || !l.message) continue;
+    const c = l.message.content;
+    let text = null;
+    if (typeof c === 'string') text = c;
+    else if (Array.isArray(c)) {
+      const b = c.find((x) => x && x.type === 'text' && typeof x.text === 'string');
+      if (b) text = b.text;
+    }
+    if (text === null) continue;
+    return parseTag(text);
+  }
+  return null;
+}
+
+/**
+ * Summarize a transcript segment. Usage counted once per requestId (last line wins).
+ * opts.afterUuids: uuids already counted by earlier segments; the segment starts after
+ * the last line carrying one of them.
+ */
+function summarizeTranscript(lines, opts) {
+  const o = opts || {};
+  let start = 0;
+  if (o.afterUuids && o.afterUuids.size) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (lines[i] && o.afterUuids.has(lines[i].uuid)) { start = i + 1; break; }
+    }
+  }
+  const seg = lines.slice(start);
+  const byReq = new Map();
+  const toolIds = new Set();
+  let anonTools = 0;
+  let anonReq = 0;
+  let firstTs = null;
+  let lastTs = null;
+  for (const l of seg) {
+    if (!l || typeof l !== 'object') continue;
+    if (typeof l.timestamp === 'string') {
+      const t = Date.parse(l.timestamp);
+      if (!isNaN(t)) {
+        if (firstTs === null || t < firstTs) firstTs = t;
+        if (lastTs === null || t > lastTs) lastTs = t;
+      }
+    }
+    if (l.type !== 'assistant' || !l.message || typeof l.message !== 'object') continue;
+    const msg = l.message;
+    if (msg.model === '<synthetic>') continue;
+    if (Array.isArray(msg.content)) {
+      for (const b of msg.content) {
+        if (b && b.type === 'tool_use') {
+          if (b.id) toolIds.add(b.id); else anonTools++;
+        }
+      }
+    }
+    const key = l.requestId || msg.id || l.uuid || `anon-${anonReq++}`;
+    if (msg.usage) byReq.set(key, { usage: msg.usage, model: msg.model });
+    else if (!byReq.has(key)) byReq.set(key, { usage: null, model: msg.model });
+  }
+
+  const tokens = { input: 0, output: 0, thinking: 0, cache_write_5m: 0, cache_write_1h: 0, cache_read: 0 };
+  let cost = 0;
+  let costKnown = true;
+  const modelCount = new Map();
+  for (const { usage, model } of byReq.values()) {
+    if (model) modelCount.set(model, (modelCount.get(model) || 0) + 1);
+    if (!usage) continue;
+    const b = usageBuckets(usage);
+    for (const k of Object.keys(tokens)) tokens[k] += b[k];
+    const c = o.pricing ? requestCost(o.pricing, model, b) : null;
+    if (c === null) costKnown = false; else cost += c;
+  }
+  let model = null;
+  let best = -1;
+  for (const [m, n] of modelCount) if (n > best) { best = n; model = m; }
+
+  return {
+    segment_start: start,
+    lines: seg.length,
+    duration_s: firstTs !== null && lastTs !== null ? Math.round((lastTs - firstTs) / 100) / 10 : null,
+    api_calls: byReq.size,
+    tool_uses: toolIds.size + anonTools,
+    tokens,
+    cost_usd: costKnown && byReq.size ? Math.round(cost * 1e8) / 1e8 : (byReq.size ? null : 0),
+    model: normalizeModel(model),
+    last_uuid: lastUuidOf(seg),
+  };
+}
+
+// ------------------------------------------------------------------ events (append-only)
+
+/** Append one event. events.jsonl is append-only: never rewritten, sync progress lives elsewhere. */
+function appendEvent(ctx, ev) {
+  fs.mkdirSync(ctx.paths.data, { recursive: true });
+  fs.appendFileSync(ctx.paths.events, `${JSON.stringify(ev)}\n`);
+}
+
+function readEventsBuffer(ctx) {
+  try { return fs.readFileSync(ctx.paths.events); } catch (_) { return Buffer.alloc(0); }
+}
+
+/**
+ * Complete lines of events.jsonl starting at byte `from`, with their byte ranges.
+ * A trailing line without '\n' (append in progress) is excluded.
+ */
+function eventLinesFrom(buf, from) {
+  const out = [];
+  let pos = Math.max(0, Math.min(from || 0, buf.length));
+  for (;;) {
+    const nl = buf.indexOf(0x0a, pos);
+    if (nl < 0) break;
+    const text = buf.toString('utf8', pos, nl).replace(/\r$/, '');
+    if (text.trim()) out.push({ text, start: pos, end: nl + 1 });
+    pos = nl + 1;
+  }
+  return out;
+}
+
+function readEventLines(ctx) {
+  return eventLinesFrom(readEventsBuffer(ctx), 0).map((l) => l.text);
+}
+
+function readEvents(ctx) {
+  const out = [];
+  for (const line of readEventLines(ctx)) {
+    try {
+      const o = JSON.parse(line);
+      if (o && typeof o === 'object') out.push(o);
+    } catch (_) { /* skip */ }
+  }
+  return out;
+}
+
+/** Byte offset just past the last event already pushed to the sink. */
+function loadSyncOffset(ctx) {
+  const s = readJsonFile(ctx.paths.syncOffset, null);
+  const n = s && Number(s.offset);
+  return Number.isFinite(n) && n >= 0 ? n : 0;
+}
+
+function saveSyncOffset(ctx, offset) {
+  writeFileAtomic(ctx.paths.syncOffset, `${JSON.stringify({ offset, ts: nowIso() })}\n`);
+}
+
+/** Events written after the sync offset (not yet on the sink). */
+function unsyncedInfo(ctx) {
+  const buf = readEventsBuffer(ctx);
+  let off = loadSyncOffset(ctx);
+  if (off > buf.length) off = 0; // file replaced/truncated
+  const lines = eventLinesFrom(buf, off);
+  return { offset: off, size: buf.length, lines: lines.length, bytes: buf.length - off };
+}
+
+// ------------------------------------------------------------------ small state files
+
+function safeName(id) {
+  const s = String(id).replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 80);
+  return s === String(id) ? s : `${s}-${sha8(id)}`;
+}
+
+function segmentFile(ctx, agentId) {
+  return path.join(ctx.paths.segments, `${safeName(agentId)}.json`);
+}
+
+/** Per-agent segment record: { uuids: [last uuid of each counted segment], n, t }. */
+function loadSegments(ctx, agentId) {
+  const s = readJsonFile(segmentFile(ctx, agentId), null);
+  if (!s || !Array.isArray(s.uuids)) return { uuids: [], n: 0 };
+  return s;
+}
+
+function saveSegments(ctx, agentId, rec) {
+  writeFileAtomic(segmentFile(ctx, agentId), `${JSON.stringify(rec)}\n`);
+}
+
+// ------------------------------------------------------------------ hook handlers
+
+function extractAgentId(tr) {
+  if (!tr) return null;
+  if (typeof tr === 'object' && !Array.isArray(tr)) {
+    const v = tr.agentId || tr.agent_id;
+    if (typeof v === 'string' && v) return v;
+  }
+  let s;
+  try { s = typeof tr === 'string' ? tr : JSON.stringify(tr); } catch (_) { return null; }
+  const m = /agent_?[Ii]d(?:\\?")?\s*[:=]\s*(?:\\?")?([A-Za-z0-9_-]{6,64})/.exec(s || '');
+  return m ? m[1] : null;
+}
+
+function buildDispatch(p, ctx) {
+  const ti = p.tool_input && typeof p.tool_input === 'object' ? p.tool_input : {};
+  const tr = p.tool_response;
+  const trObj = tr && typeof tr === 'object' && !Array.isArray(tr) ? tr : {};
+  const tag = parseTag(ti.prompt) || UNTAGGED;
+  const explicitEffort = typeof ti.effort === 'string' && ti.effort ? ti.effort : null;
+  const parentEffort = p.effort && typeof p.effort === 'object' ? p.effort.level : null;
+  // agent_id must never be empty (the sink keys on it): agentId -> tool_use_id -> random.
+  const agentId = extractAgentId(tr)
+    || (typeof p.tool_use_id === 'string' && p.tool_use_id ? p.tool_use_id : null)
+    || `noid-${crypto.randomBytes(6).toString('hex')}`;
+  return Object.assign({
+    schema: SCHEMA,
+    kind: 'dispatch',
+    ts: nowIso(),
+    agent_id: agentId,
+    session: p.session_id ? sha8(p.session_id) : null,
+    task_id: tag.task_id,
+    task_type: tag.task_type,
+    score: tag.score,
+    urgency: tag.urgency,
+    try: tag.try,
+    role: tag.role,
+    model: normalizeModel(trObj.resolvedModel) || normalizeModel(ti.model) || null,
+    effort: explicitEffort || parentEffort || null,
+    effort_inherited: !explicitEffort,
+    subagent_type: typeof ti.subagent_type === 'string' && ti.subagent_type ? ti.subagent_type : 'general-purpose',
+    background: ti.run_in_background === true || trObj.isAsync === true,
+  }, commonFields(ctx));
+}
+
+function handlePostToolUse(p, ctx) {
+  if (p.tool_name !== 'Agent' && p.tool_name !== 'Task') return null;
+  const ev = buildDispatch(p, ctx);
+  appendEvent(ctx, ev);
+  return ev;
+}
+
+function handleSubagentStop(p, ctx) {
+  const agentId = typeof p.agent_id === 'string' && p.agent_id ? p.agent_id : null;
+  if (!agentId) return null;
+  const prev = loadSegments(ctx, agentId);
+  const seen = new Set(prev.uuids || []);
+  let sum = null;
+  let tag = null;
+  const tpath = p.agent_transcript_path;
+  if (typeof tpath === 'string' && tpath && fs.existsSync(tpath)) {
+    const lines = readTranscript(tpath);
+    const last = lastUuidOf(lines);
+    if (last && seen.has(last)) return null; // same segment reported twice
+    sum = summarizeTranscript(lines, { afterUuids: seen, pricing: loadPricing(ctx) });
+    tag = tagFromTranscript(lines);
+  }
+  const t = tag || UNTAGGED;
+  const ev = Object.assign({
+    schema: SCHEMA,
+    kind: 'complete',
+    ts: nowIso(),
+    agent_id: agentId,
+    session: p.session_id ? sha8(p.session_id) : null,
+    segment: (prev.n || 0) + 1,
+    task_id: t.task_id,
+    task_type: t.task_type,
+    try: t.try,
+    role: t.role,
+    subagent_type: typeof p.agent_type === 'string' ? p.agent_type : null,
+    effort: p.effort && typeof p.effort === 'object' && p.effort.level ? p.effort.level : null,
+    duration_s: sum ? sum.duration_s : null,
+    api_calls: sum ? sum.api_calls : null,
+    tool_uses: sum ? sum.tool_uses : null,
+    tokens: sum ? sum.tokens : null,
+    cost_usd: sum ? sum.cost_usd : null,
+    model: sum ? sum.model : null,
+  }, commonFields(ctx));
+  // Record the segment before appending so a racing duplicate fire sees it.
+  if (sum && sum.last_uuid) {
+    saveSegments(ctx, agentId, {
+      uuids: Array.from(seen).concat(sum.last_uuid).slice(-50),
+      n: ev.segment,
+      t: Date.now(),
+    });
+  }
+  appendEvent(ctx, ev);
+  return ev;
+}
+
+function maybeSpawnSync(ctx) {
+  if (!ctx.config.sink_url || !ctx.config.sink_token) return false;
+  if (process.env.DIEU_PHOI_NO_SPAWN === '1') return false;
+  const last = Number((readJsonFile(ctx.paths.syncSpawn, {}) || {}).t) || 0;
+  if (Date.now() - last < SYNC_SPAWN_INTERVAL_MS) return false;
+  writeFileAtomic(ctx.paths.syncSpawn, `${JSON.stringify({ t: Date.now() })}\n`);
+  const cp = require('child_process');
+  const child = cp.spawn(process.execPath, [__filename, '--sync'], {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    env: Object.assign({}, process.env, { DIEU_PHOI_HOME: ctx.home }),
+  });
+  child.on('error', (e) => logError(ctx.home, e, 'spawn-sync'));
+  child.unref();
+  return true;
+}
+
+function readStdin() {
+  const chunks = [];
+  const buf = Buffer.alloc(65536);
+  for (;;) {
+    let n;
+    try {
+      n = fs.readSync(0, buf, 0, buf.length, null);
+    } catch (e) {
+      if (e.code === 'EAGAIN') { sleepSync(5); continue; }
+      if (e.code === 'EOF') break;
+      throw e;
+    }
+    if (!n) break;
+    chunks.push(Buffer.from(buf.subarray(0, n)));
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+/** Process one hook payload. Never throws. Returns the written event (or null). */
+function runHook(opts) {
+  const o = opts || {};
+  let home = null;
+  try {
+    home = resolveHome(o.home);
+    const raw = typeof o.input === 'string' ? o.input : readStdin();
+    if (!raw || !raw.trim()) return null;
+    const p = JSON.parse(raw.replace(/^/, ''));
+    const ctx = makeCtx(home);
+    let ev = null;
+    const name = p.hook_event_name;
+    if (name === 'SubagentStop') ev = handleSubagentStop(p, ctx);
+    else if (name === 'PostToolUse' || (!name && p.tool_name)) ev = handlePostToolUse(p, ctx);
+    if (ev) {
+      try { maybeSpawnSync(ctx); } catch (e) { logError(home, e, 'spawn-sync'); }
+    }
+    return ev;
+  } catch (e) {
+    logError(home, e, 'hook');
+    return null;
+  }
+}
+
+// ------------------------------------------------------------------ sync
+
+function acquireLock(file) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  try {
+    const st = fs.statSync(file);
+    if (Date.now() - st.mtimeMs > 5 * 60 * 1000) fs.unlinkSync(file);
+  } catch (_) { /* no lock */ }
+  try {
+    fs.writeFileSync(file, String(process.pid), { flag: 'wx' });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+async function postBatch(url, token, records, o) {
+  const fetchImpl = o.fetch || globalThis.fetch;
+  let lastErr = null;
+  for (let attempt = 0; attempt <= o.retries; attempt++) {
+    if (attempt > 0) await new Promise((r) => setTimeout(r, o.backoffMs * 2 ** (attempt - 1)));
+    try {
+      const res = await fetchImpl(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ token, records }),
+        redirect: 'follow',
+        signal: AbortSignal.timeout(o.timeoutMs),
+      });
+      const text = await res.text();
+      let body = null;
+      try { body = JSON.parse(text); } catch (_) { /* non-JSON */ }
+      if (res.ok && body && body.ok === true) return body;
+      lastErr = new Error(`sink trả về ${res.status}: ${String(text).slice(0, 200)}`);
+      if (res.status >= 400 && res.status < 500 && res.status !== 408 && res.status !== 429) break;
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  throw lastErr || new Error('sink lỗi không rõ');
+}
+
+/**
+ * Keep records the sink refused in data/sync-rejected.jsonl (never silently lost).
+ * Accepts `rejected_items: [{index, error}]` (or `rejected` as that array), or the count form
+ * `rejected: n` + `errors: ["#i: msg", ...]`; rejects that cannot be matched to an index are
+ * written as one summary line. Returns the number of rejected records.
+ */
+function recordRejected(ctx, records, body) {
+  const items = Array.isArray(body.rejected_items) ? body.rejected_items
+    : (Array.isArray(body.rejected) ? body.rejected : null);
+  const count = items ? items.length : (Number(body.rejected) || 0);
+  if (!count) return 0;
+  const ts = nowIso();
+  const lines = [];
+  const seen = new Set();
+  const add = (idx, error) => {
+    if (!Number.isInteger(idx) || idx < 0 || idx >= records.length || seen.has(idx)) return;
+    seen.add(idx);
+    lines.push({ ts, error: String(error || 'rejected'), record: records[idx] });
+  };
+  if (items) {
+    for (const it of items) add(Number(it && it.index), it && it.error);
+  } else if (Array.isArray(body.errors)) {
+    for (const e of body.errors) {
+      const m = /^#(\d+):\s*(.*)$/.exec(String(e));
+      if (m) add(Number(m[1]), m[2]);
+    }
+  }
+  if (seen.size < count) {
+    lines.push({ ts, error: 'sink rejected records without per-record detail', unidentified: count - seen.size,
+      errors: Array.isArray(body.errors) ? body.errors.slice(0, 10) : null });
+  }
+  fs.mkdirSync(ctx.paths.data, { recursive: true });
+  fs.appendFileSync(ctx.paths.syncRejected, lines.map((l) => `${JSON.stringify(l)}\n`).join(''));
+  return count;
+}
+
+/**
+ * Push events written after the sync offset, in batches of <= batchSize. events.jsonl is
+ * never rewritten; after each accepted batch the offset (byte just past the batch's last
+ * line) is saved atomically to data/sync-offset.json. No-op without a sink.
+ */
+async function runSync(ctx, opts) {
+  const o = Object.assign({
+    batchSize: 200, retries: 3, timeoutMs: 20000,
+    backoffMs: Number(process.env.DIEU_PHOI_BACKOFF_MS) || 1000,
+  }, opts);
+  const cfg = ctx.config || {};
+  if (!cfg.sink_url || !cfg.sink_token) return { ok: true, skipped: 'no-sink', sent: 0, batches: 0 };
+  if (!acquireLock(ctx.paths.lock)) return { ok: true, skipped: 'locked', sent: 0, batches: 0 };
+  const result = { ok: true, sent: 0, batches: 0, accepted: 0, duplicates: 0, rejected: 0, error: null };
+  try {
+    const buf = readEventsBuffer(ctx);
+    let offset = loadSyncOffset(ctx);
+    if (offset > buf.length) offset = 0;
+    const lines = eventLinesFrom(buf, offset);
+    for (let i = 0; i < lines.length; i += o.batchSize) {
+      const batch = lines.slice(i, i + o.batchSize);
+      const records = [];
+      for (const l of batch) {
+        try {
+          const r = JSON.parse(l.text);
+          if (r && typeof r === 'object' && !Array.isArray(r)) {
+            delete r.synced;
+            records.push(r);
+          }
+        } catch (_) { /* corrupt line: skip, offset still advances */ }
+      }
+      try {
+        if (records.length) {
+          const body = await postBatch(cfg.sink_url, cfg.sink_token, records, o);
+          result.accepted += Number(body.accepted) || 0;
+          result.duplicates += Number(body.duplicates) || 0;
+          result.rejected += recordRejected(ctx, records, body);
+        }
+        saveSyncOffset(ctx, batch[batch.length - 1].end);
+        result.batches++;
+        result.sent += records.length;
+      } catch (e) {
+        result.ok = false;
+        result.error = String(e && e.message ? e.message : e);
+        break;
+      }
+    }
+  } finally {
+    try {
+      writeFileAtomic(ctx.paths.lastSync, `${JSON.stringify({
+        ts: nowIso(), ok: result.ok, sent: result.sent, error: result.error,
+      })}\n`);
+    } catch (_) { /* best effort */ }
+    try { fs.unlinkSync(ctx.paths.lock); } catch (_) { /* gone */ }
+  }
+  return result;
+}
+
+// ------------------------------------------------------------------ exports / main
+
+module.exports = {
+  CORE_VERSION, SCHEMA, TASK_TYPES, URGENCIES, ROLES, MODEL_ALIASES, UNTAGGED,
+  sha8, nowIso, readJsonFile, writeFileAtomic, defaultClaudeDir, resolveHome, pathsFor, loadConfig, makeCtx,
+  logError, computeUserHash, userHash, commonFields, parseTag, normalizeModel, loadPricing,
+  priceFor, usageBuckets, requestCost, parseJsonl, readTranscript, lastUuidOf,
+  tagFromTranscript, summarizeTranscript, appendEvent, eventLinesFrom, readEventLines, readEvents,
+  loadSyncOffset, saveSyncOffset, recordRejected, unsyncedInfo, loadSegments, saveSegments, segmentFile,
+  extractAgentId, buildDispatch, handlePostToolUse, handleSubagentStop, maybeSpawnSync, runHook, runSync,
+};
+
+if (require.main === module) {
+  process.on('uncaughtException', (e) => { logError(null, e, 'uncaught'); process.exit(0); });
+  process.on('unhandledRejection', (e) => { logError(null, e, 'unhandled'); process.exit(0); });
+  if (process.argv.includes('--sync')) {
+    const ctx = makeCtx();
+    runSync(ctx)
+      .then((r) => { if (!r.ok) logError(ctx.home, new Error(r.error), 'sync'); })
+      .catch((e) => logError(ctx.home, e, 'sync'))
+      .finally(() => process.exit(0));
+  } else {
+    runHook();
+    process.exitCode = 0;
+  }
+}