@costrict/csc 4.2.6 → 4.2.7-beta2

package/dist/services/rawDump/batchWorker.js

@@ -456,10 +456,10 @@ async function appendDeadLetter(entry) {
 }
 
 // src/services/rawDump/worker.ts
-import { promises as fs8 } from "fs";
+import { promises as fs9 } from "fs";
 import { createHash as createHash2 } from "crypto";
 import os2 from "os";
-import path8 from "path";
+import path11 from "path";
 import { fileURLToPath } from "url";
 
 // src/costrict/provider/credentials.ts
@@ -508,8 +508,8 @@ async function saveCoStrictCredentials(credentials) {
 import { createRequire } from "module";
 function getVersion() {
   try {
-    if (typeof MACRO !== "undefined" && "4.2.6")
-      return "4.2.6";
+    if (typeof MACRO !== "undefined" && "4.2.7-beta2")
+      return "4.2.7-beta2";
   } catch {}
   try {
     const require2 = createRequire(import.meta.url);
@@ -594,8 +594,11 @@ async function refreshCoStrictToken(params) {
 
 // src/services/rawDump/git.ts
 import { execFile } from "child_process";
+import { realpathSync } from "fs";
+import path4 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
+var TRUNK_BRANCHES = ["origin/main", "origin/master", "main", "master"];
 async function gitExec(args, cwd) {
   try {
     const { stdout } = await execFileAsync("git", args, {
@@ -610,19 +613,63 @@ async function gitExec(args, cwd) {
   }
 }
 async function getRepoInfo(cwd) {
-  const [repoAddr, repoBranch, gitUserName, gitUserEmail] = await Promise.all([
+  const [repoAddr, repoBranch, gitUserName, gitUserEmail, gitRoot] = await Promise.all([
     gitExec(["remote", "get-url", "origin"], cwd),
     gitExec(["branch", "--show-current"], cwd),
     gitExec(["config", "user.name"], cwd),
-    gitExec(["config", "user.email"], cwd)
+    gitExec(["config", "user.email"], cwd),
+    gitExec(["rev-parse", "--show-toplevel"], cwd)
   ]);
   return {
     repo_addr: repoAddr,
     repo_branch: repoBranch,
     git_user_name: gitUserName,
-    git_user_email: gitUserEmail
+    git_user_email: gitUserEmail,
+    git_root: gitRoot
   };
 }
+function computeRepoRelativePath(gitRoot, workDir) {
+  if (!gitRoot)
+    return "";
+  const root = tryRealpath(gitRoot);
+  const dir = tryRealpath(workDir);
+  const rel = path4.relative(root, dir);
+  if (rel === "")
+    return ".";
+  if (rel.startsWith(".."))
+    return "";
+  return rel;
+}
+function tryRealpath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return path4.resolve(p);
+  }
+}
+async function getBranchAncestry(cwd) {
+  const upstream = await gitExec(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], cwd);
+  if (upstream && TRUNK_BRANCHES.includes(upstream)) {
+    const forkPoint = await gitExec(["merge-base", upstream, "HEAD"], cwd);
+    return { base_branch: upstream, fork_point: forkPoint };
+  }
+  const candidates = TRUNK_BRANCHES;
+  let best = null;
+  for (const base of candidates) {
+    const forkPoint = await gitExec(["merge-base", base, "HEAD"], cwd);
+    if (!forkPoint)
+      continue;
+    const countOut = await gitExec(["rev-list", "--count", `${forkPoint}..HEAD`], cwd);
+    const distance = Number.parseInt(countOut, 10);
+    const dist = Number.isNaN(distance) ? Number.MAX_SAFE_INTEGER : distance;
+    if (!best || dist < best.distance) {
+      best = { base, forkPoint, distance: dist };
+    }
+  }
+  if (best)
+    return { base_branch: best.base, fork_point: best.forkPoint };
+  return { base_branch: "", fork_point: "" };
+}
 function countDiffLines(diff) {
   let count = 0;
   for (const line of diff.split(`
@@ -706,9 +753,69 @@ function toCommitComment(subject) {
   return Array.from(subject).slice(0, 150).join("");
 }
 
+// src/services/rawDump/activeSessions.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, renameSync, realpathSync as realpathSync2 } from "fs";
+import path5 from "path";
+var log2 = createLogger("activeSessions");
+var ACTIVE_SESSIONS_FILE = path5.join(getRawDumpDir(), "csc-active-sessions.json");
+var DEFAULT_WINDOW_MS = 30 * 60 * 1000;
+var FUTURE_TOLERANCE_MS = 5 * 60 * 1000;
+var MAX_ACTIVE_SESSION_IDS = 64;
+function getWindowMs() {
+  const v = process.env.CSC_ACTIVE_SESSION_WINDOW_MS;
+  if (v) {
+    const n = Number(v);
+    if (Number.isFinite(n) && n > 0)
+      return n;
+  }
+  return DEFAULT_WINDOW_MS;
+}
+function normalizeCwd(p) {
+  if (!p)
+    return "";
+  let resolved;
+  try {
+    resolved = realpathSync2(p);
+  } catch {
+    resolved = path5.resolve(p);
+  }
+  if (resolved.length > 1 && resolved.endsWith(path5.sep)) {
+    resolved = resolved.slice(0, -1);
+  }
+  return resolved;
+}
+function readMap() {
+  try {
+    const text = readFileSync2(ACTIVE_SESSIONS_FILE, "utf-8");
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function getActiveSessionIds(cwd, atMs) {
+  const ref = atMs ?? Date.now();
+  const windowMs = getWindowMs();
+  const refCwd = normalizeCwd(cwd);
+  const map = readMap();
+  const hits = [];
+  for (const [sid, entry] of Object.entries(map)) {
+    const delta = ref - entry.lastSeenAt;
+    if (delta > windowMs)
+      continue;
+    if (delta < -FUTURE_TOLERANCE_MS)
+      continue;
+    if (refCwd && entry.cwd && entry.cwd !== refCwd)
+      continue;
+    hits.push({ sid, lastSeenAt: entry.lastSeenAt });
+  }
+  hits.sort((a, b) => b.lastSeenAt - a.lastSeenAt);
+  return hits.slice(0, MAX_ACTIVE_SESSION_IDS).map((h) => h.sid);
+}
+
 // src/services/rawDump/localStorage.ts
 import { promises as fs4 } from "fs";
-import path4 from "path";
+import path6 from "path";
 var DEFAULT_LOCAL_DIR = getRawDumpDir();
 var RAW_DUMP_MODE = {
   DISABLED: 0,
@@ -757,12 +864,12 @@ async function writeLocalDump(type, body) {
     endpoint = "/raw-store/task-summary";
   } else if (type == "conversation") {
     ymd = getDateFromTimestamp(getTimestampField("conversation", body));
-    subdir = path4.join(ymd, body.task_id);
+    subdir = path6.join(ymd, body.task_id);
     fname = body.request_id;
     endpoint = "/raw-store/task-conversation";
   } else if (type == "commit") {
     ymd = getDateFromTimestamp(getTimestampField("commit", body));
-    subdir = path4.join(normalizeProjectPath2(body.repo_addr), normalizeProjectPath2(body.repo_branch), ymd);
+    subdir = path6.join(normalizeProjectPath2(body.repo_addr), normalizeProjectPath2(body.repo_branch), ymd);
     fname = body.commit_id;
     endpoint = "/raw-store/commit";
   } else if (type == "statistics") {
@@ -774,7 +881,7 @@ async function writeLocalDump(type, body) {
     fname = `${h}-${m}-${s}`;
     endpoint = "/raw-store/statistics";
   } else if (type == "raw") {
-    subdir = path4.join(normalizeProjectPath2(body.project), body.session_id);
+    subdir = path6.join(normalizeProjectPath2(body.project), body.session_id);
     fname = String(body.start_cursor);
     endpoint = "/raw-store/raw-log";
   } else {
@@ -782,9 +889,9 @@ async function writeLocalDump(type, body) {
     fname = "unknown";
     endpoint = "unknown";
   }
-  const dumpDir = path4.join(dir, type, subdir);
+  const dumpDir = path6.join(dir, type, subdir);
   const filename = `${fname}.json`;
-  const filePath = path4.join(dumpDir, filename);
+  const filePath = path6.join(dumpDir, filename);
   const payload = {
     _dumpMeta: {
       type,
@@ -799,10 +906,69 @@ async function writeLocalDump(type, body) {
 }
 
 // src/services/rawDump/queue.ts
+import { promises as fs6 } from "fs";
+import path8 from "path";
+
+// src/services/rawDump/lock.ts
 import { promises as fs5 } from "fs";
-import path5 from "path";
-var QUEUE_FILE = path5.join(getRawDumpDir(), "csc-work-queue.jsonl");
-var QUEUE_LOCK_FILE = path5.join(getRawDumpDir(), "csc-work-queue.lock");
+import path7 from "path";
+var LOCK_INFO_FILE = "lock.json";
+async function isHolderAlive(lockDir) {
+  try {
+    const text = await fs5.readFile(path7.join(lockDir, LOCK_INFO_FILE), "utf-8");
+    const info = JSON.parse(text);
+    if (!info.pid || typeof info.pid !== "number")
+      return false;
+    try {
+      process.kill(info.pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+async function acquireLock(lockDir, info) {
+  let retried = false;
+  while (true) {
+    try {
+      await fs5.mkdir(lockDir, { recursive: false });
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        if (retried)
+          return false;
+        const alive = await isHolderAlive(lockDir);
+        if (alive)
+          return false;
+        try {
+          await fs5.rm(lockDir, { recursive: true, force: true });
+        } catch {
+          return false;
+        }
+        retried = true;
+        continue;
+      }
+      return false;
+    }
+    try {
+      await fs5.writeFile(path7.join(lockDir, LOCK_INFO_FILE), JSON.stringify(info), "utf-8");
+      return true;
+    } catch {
+      await releaseLock(lockDir);
+      return false;
+    }
+  }
+}
+async function releaseLock(lockDir) {
+  try {
+    await fs5.rm(lockDir, { recursive: true, force: true });
+  } catch {}
+}
+
+// src/services/rawDump/queue.ts
+var QUEUE_FILE = path8.join(getRawDumpDir(), "csc-work-queue.jsonl");
+var QUEUE_LOCK_DIR = path8.join(getRawDumpDir(), "csc-work-queue.lock.d");
 var MAX_ATTEMPTS = 4;
 var queue = [];
 var queueLoaded = false;
@@ -810,7 +976,7 @@ async function loadQueue() {
   if (queueLoaded)
     return;
   try {
-    const text = await fs5.readFile(QUEUE_FILE, "utf-8");
+    const text = await fs6.readFile(QUEUE_FILE, "utf-8");
     queue = text.split(`
 `).filter(Boolean).map((line) => {
       try {
@@ -826,51 +992,37 @@ async function loadQueue() {
 }
 function clearQueue() {
   queue = [];
-  fs5.writeFile(QUEUE_FILE, "", "utf-8").catch(() => {});
+  fs6.writeFile(QUEUE_FILE, "", "utf-8").catch(() => {});
 }
 function getQueue() {
   return [...queue];
 }
 async function acquireQueueLock() {
-  try {
-    try {
-      const stat2 = await fs5.readFile(QUEUE_LOCK_FILE, "utf-8");
-      const pid = parseInt(stat2, 10);
-      if (!isNaN(pid) && pid !== process.pid) {
-        try {
-          process.kill(pid, 0);
-          return false;
-        } catch {}
-      }
-    } catch {}
-    await fs5.writeFile(QUEUE_LOCK_FILE, String(process.pid), "utf-8");
-    return true;
-  } catch {
-    return false;
-  }
+  return acquireLock(QUEUE_LOCK_DIR, {
+    pid: process.pid,
+    startedAt: new Date().toISOString()
+  });
 }
 async function releaseQueueLock() {
-  try {
-    await fs5.writeFile(QUEUE_LOCK_FILE, "", "utf-8");
-  } catch {}
+  await releaseLock(QUEUE_LOCK_DIR);
 }
 
 // src/services/rawDump/history.ts
-import { promises as fs6 } from "fs";
-import path6 from "path";
-var HISTORY_FILE = path6.join(getCscDir(), "history.jsonl");
+import { promises as fs7 } from "fs";
+import path9 from "path";
+var HISTORY_FILE = path9.join(getCscDir(), "history.jsonl");
 var cache = null;
 async function loadHistory() {
   const items = [];
   let fileStat = null;
   try {
-    fileStat = await fs6.stat(HISTORY_FILE);
+    fileStat = await fs7.stat(HISTORY_FILE);
   } catch {
     cache = null;
     return [];
   }
   try {
-    const content = await fs6.readFile(HISTORY_FILE, "utf-8");
+    const content = await fs7.readFile(HISTORY_FILE, "utf-8");
     const lines = content.split(`
 `);
     for (const line of lines) {
@@ -894,7 +1046,7 @@ async function loadHistory() {
 async function autoLoadHistory() {
   let fileStat = null;
   try {
-    fileStat = await fs6.stat(HISTORY_FILE);
+    fileStat = await fs7.stat(HISTORY_FILE);
   } catch {
     if (cache) {
       return null;
@@ -910,7 +1062,7 @@ async function getProjectDirs() {
   if (cache) {
     let fileStat = null;
     try {
-      fileStat = await fs6.stat(HISTORY_FILE);
+      fileStat = await fs7.stat(HISTORY_FILE);
     } catch {
       return [...new Set(cache.items.map((item) => item.project))];
     }
@@ -923,8 +1075,8 @@ async function getProjectDirs() {
 }
 
 // src/services/rawDump/session.ts
-import { promises as fs7 } from "fs";
-import path7 from "path";
+import { promises as fs8 } from "fs";
+import path10 from "path";
 
 // src/services/rawDump/parse.ts
 function buildFlows(events) {
@@ -983,12 +1135,15 @@ function createConversation(convEvents) {
     duration: 0,
     sender: "",
     diffs: [],
+    toolEvents: [],
+    model: "",
+    promptMode: "",
     preview: "",
     requestContent: "",
     responseContent: ""
   };
 }
-function fillConversation(conv) {
+function fillConversation(conv, allSessionEvents) {
   if (conv.diffs.length > 0 || conv.startTime || conv.inputTokens > 0)
     return;
   let inputTokens = 0;
@@ -1028,12 +1183,19 @@ function fillConversation(conv) {
       responseTexts.push(text);
   }
   const diffs = [];
+  const toolEvents = [];
+  let model = "";
   conv.events.forEach((evt) => {
     if (evt.type === "assistant") {
-      diffs.push(...extractEventToolDiff(evt, conv.events));
+      diffs.push(...extractEventToolDiff(evt, allSessionEvents));
+      toolEvents.push(...extractEventToolEvents(evt, allSessionEvents));
+      if (!model && evt.message?.model)
+        model = evt.message.model;
     }
   });
   conv.diffs = diffs;
+  conv.toolEvents = toolEvents;
+  conv.model = model;
   conv.events.forEach((evt) => {
     if (evt.type === "assistant") {
       const { error_code, error_reason } = extractError(evt);
@@ -1246,6 +1408,118 @@ function extractEventToolDiff(assistantEvent, allEvents) {
   }
   return diffs;
 }
+var FILE_EDIT_TOOLS = new Set(["Edit", "MultiEdit", "Write", "NotebookEdit"]);
+var COMMAND_TOOLS = new Set(["Bash", "BashOutput"]);
+var MAX_TOOL_CONTENT = 32 * 1024;
+function truncateToolContent(s) {
+  if (s === undefined)
+    return { value: undefined, truncated: false };
+  if (s.length <= MAX_TOOL_CONTENT)
+    return { value: s, truncated: false };
+  return { value: s.slice(0, MAX_TOOL_CONTENT), truncated: true };
+}
+function classifyToolKind(name) {
+  if (name === "Edit" || name === "MultiEdit")
+    return "edit";
+  if (name === "Write")
+    return "write";
+  if (name === "NotebookEdit")
+    return "notebook";
+  if (COMMAND_TOOLS.has(name))
+    return "command";
+  if (name === "Read" || name === "NotebookRead")
+    return "read";
+  if (name === "Grep" || name === "Glob" || name === "WebSearch")
+    return "search";
+  return "other";
+}
+function inferExitCode(tur) {
+  if (!tur)
+    return;
+  if (tur.interrupted === true)
+    return 1;
+  return 0;
+}
+function extractEventToolEvents(assistantEvent, allEvents) {
+  const events = [];
+  const msgUuid = assistantEvent.uuid;
+  if (!msgUuid)
+    return events;
+  const content = assistantEvent.message?.content;
+  if (!Array.isArray(content))
+    return events;
+  const resultById = new Map;
+  for (const m of allEvents) {
+    if (m.parentUuid !== msgUuid || m.type !== "user")
+      continue;
+    const tur = m.toolUseResult ?? m.tool_use_result;
+    if (!tur)
+      continue;
+    if (Array.isArray(m.message?.content)) {
+      for (const b of m.message.content) {
+        if (b?.type === "tool_result" && typeof b.tool_use_id === "string") {
+          resultById.set(b.tool_use_id, tur);
+        }
+      }
+    }
+  }
+  for (const block of content) {
+    if (block?.type !== "tool_use")
+      continue;
+    const toolName = block.name ?? "";
+    if (!toolName)
+      continue;
+    const toolUseId = typeof block.id === "string" ? block.id : undefined;
+    const input = block.input ?? {};
+    const tur = toolUseId ? resultById.get(toolUseId) : undefined;
+    const filePath = input.file_path ?? input.notebook_path ?? tur?.filePath ?? tur?.file_path ?? "";
+    const isFileEdit = FILE_EDIT_TOOLS.has(toolName);
+    const isCommand = COMMAND_TOOLS.has(toolName);
+    let before;
+    let after;
+    if (isFileEdit) {
+      const edits = input.edits;
+      if (Array.isArray(edits)) {
+        const befores = [];
+        const afters = [];
+        for (const e of edits) {
+          if (typeof e?.old_string === "string")
+            befores.push(e.old_string);
+          if (typeof e?.new_string === "string")
+            afters.push(e.new_string);
+        }
+        if (befores.length)
+          before = befores.join(`
+`);
+        if (afters.length)
+          after = afters.join(`
+`);
+      }
+      if (before === undefined) {
+        before = input.old_string ?? tur?.oldString ?? tur?.old_string ?? tur?.originalFile ?? tur?.original_file;
+      }
+      if (after === undefined) {
+        after = input.new_string ?? input.new_source ?? input.content ?? tur?.newString ?? tur?.new_string ?? tur?.content ?? tur?.updated_file;
+      }
+    }
+    const beforeCapped = truncateToolContent(before);
+    const afterCapped = truncateToolContent(after);
+    const touchedFiles = filePath ? [filePath] : [];
+    events.push({
+      name: toolName,
+      source: isFileEdit ? "ai" : toolName,
+      event_kind: classifyToolKind(toolName),
+      tool_use_id: toolUseId,
+      touched_files: touchedFiles,
+      command: isCommand ? input.command : undefined,
+      exit_code: isCommand ? inferExitCode(tur) : undefined,
+      before: beforeCapped.value,
+      after: afterCapped.value,
+      truncated: beforeCapped.truncated || afterCapped.truncated || undefined
+    });
+  }
+  return events;
+}
 function parseSession(cacheConversations, events) {
   const sessionId = events.find((e) => e.sessionId)?.sessionId || "unknown";
   const version = events.find((e) => e.version)?.version || "";
@@ -1265,6 +1539,23 @@ function parseSession(cacheConversations, events) {
       totalCacheCreationInputTokens += evt.message.usage.cache_creation_input_tokens || 0;
     }
   });
+  const idxByEvent = new Map;
+  events.forEach((e, i) => idxByEvent.set(e, i));
+  const permissionMarks = events.map((e, idx) => typeof e.permissionMode === "string" && e.permissionMode ? { idx, mode: e.permissionMode } : null).filter((x) => x !== null);
+  const lastSessionMode = permissionMarks.length > 0 ? permissionMarks[permissionMarks.length - 1].mode : "";
+  const resolvePromptMode = (conv) => {
+    if (permissionMarks.length === 0)
+      return "";
+    const convIdx = idxByEvent.get(conv.userEvent) ?? -1;
+    let mode = "";
+    for (const p of permissionMarks) {
+      if (p.idx <= convIdx)
+        mode = p.mode;
+      else
+        break;
+    }
+    return mode || lastSessionMode;
+  };
   const flows = buildFlows(events);
   flows.forEach((flow) => {
     const convResults = splitFlowToConversations(flow);
@@ -1282,7 +1573,10 @@ function parseSession(cacheConversations, events) {
   conversations.forEach((conv, i) => {
     conv.index = i;
   });
-  conversations.forEach((conv) => fillConversation(conv));
+  conversations.forEach((conv) => fillConversation(conv, events));
+  conversations.forEach((conv) => {
+    conv.promptMode = resolvePromptMode(conv);
+  });
   return {
     id: sessionId,
     version,
@@ -1300,10 +1594,10 @@ function parseSession(cacheConversations, events) {
 }
 
 // src/services/rawDump/session.ts
-var log2 = createLogger("session");
+var log3 = createLogger("session");
 async function loadSessionMessages(sessionFile) {
   try {
-    const text = await fs7.readFile(sessionFile, "utf-8");
+    const text = await fs8.readFile(sessionFile, "utf-8");
     const messages = text.split(`
 `).filter(Boolean).map((line) => {
       try {
@@ -1312,7 +1606,7 @@ async function loadSessionMessages(sessionFile) {
         return null;
       }
     }).filter((m) => m !== null);
-    log2.debug("loaded messages from file", {
+    log3.debug("loaded messages from file", {
       sessionFile,
       count: messages.length
     });
@@ -1335,10 +1629,10 @@ async function getParsedSession(taskDir, sessionId) {
   const sessionDir = getSessionDirectory(taskDir);
   const cacheKey = `${sessionDir}:${sessionId}`;
   const cached = sessionMessagesCache.get(cacheKey);
-  const sessionFile = path7.join(sessionDir, `${sessionId}.jsonl`);
+  const sessionFile = path10.join(sessionDir, `${sessionId}.jsonl`);
   let stats;
   try {
-    stats = await fs7.stat(sessionFile);
+    stats = await fs8.stat(sessionFile);
   } catch {
     return {
       sessionJsonlFileName: sessionFile,
@@ -1351,7 +1645,7 @@ async function getParsedSession(taskDir, sessionId) {
   }
   const needsReanalysis = !cached || cached.fileTimestamp !== stats.mtimeMs || cached.fileSize !== stats.size || !cached.parsedSession;
   if (!needsReanalysis && cached) {
-    log2.debug("using cached parsed session", { sessionId });
+    log3.debug("using cached parsed session", { sessionId });
     return cached;
   }
   cleanupOldSessions();
@@ -1359,7 +1653,7 @@ async function getParsedSession(taskDir, sessionId) {
   const messages = cached?.messages ?? await loadSessionMessages(sessionFile);
   const elapsed = Date.now() - start;
   if (elapsed > 100) {
-    log2.info("loadSessionMessages slow", { sessionId, elapsedMs: elapsed });
+    log3.info("loadSessionMessages slow", { sessionId, elapsedMs: elapsed });
   }
   const cachedConvs = cached?.parsedSession?.conversations ?? [];
   const parsedSession = parseSession(cachedConvs, messages);
@@ -1376,7 +1670,7 @@ async function getParsedSession(taskDir, sessionId) {
 }
 
 // src/services/rawDump/statistics.ts
-var log3 = createLogger("worker");
+var log4 = createLogger("worker");
 async function updateStatisticsForUpload() {
   const dailyStats = await statHistorySessions();
   for (const [_dateKey, stats] of dailyStats) {
@@ -1390,7 +1684,7 @@ async function updateStatisticsForUpload() {
     } else {
       const startTime = new Date(_dateKey);
       if (state_statistics.clean_time && startTime < new Date(state_statistics.clean_time)) {
-        log3.info("statistics skipped: too old", {
+        log4.info("statistics skipped: too old", {
           startTime: startTime.toISOString(),
           clean_time: state_statistics.clean_time
         });
@@ -1500,9 +1794,21 @@ async function statHistorySessions() {
 }
 
 // src/services/rawDump/worker.ts
-var log4 = createLogger("worker");
+var log5 = createLogger("worker");
 var CSC_DIR = getCscDir();
 var REQUEST_TIMEOUT_MS = 30000;
+var TOOL_EVENTS_PAYLOAD_BUDGET = 256 * 1024;
+function capToolEventsPayload(events) {
+  let used = 0;
+  return events.map((e) => {
+    const size = (e.before?.length ?? 0) + (e.after?.length ?? 0);
+    if (size > 0 && used + size > TOOL_EVENTS_PAYLOAD_BUDGET) {
+      return { ...e, before: undefined, after: undefined, truncated: true };
+    }
+    used += size;
+    return e;
+  });
+}
 var repoInfoCache = new Map;
 var REPO_CACHE_TTL_MS = 60000;
 async function getCachedRepoInfo(directory) {
@@ -1515,13 +1821,13 @@ async function getCachedRepoInfo(directory) {
   return repoInfo;
 }
 async function processTask(task, authData) {
-  log4.info("processing task:", { task });
+  log5.info("processing task:", { task });
   await uploadRaw(task.sessionId, task.directory, authData);
   const repoInfo = await getCachedRepoInfo(task.directory);
   const cacheEntry = await getParsedSession(task.directory, task.sessionId);
   const parsedSession = cacheEntry.parsedSession;
   if (parsedSession.conversations.length === 0) {
-    log4.warn("no conversations found", { task });
+    log5.warn("no conversations found", { task });
   }
   await uploadSummary({ sessionId: task.sessionId, directory: task.directory, parsedSession }, authData);
   for (const conv of parsedSession.conversations) {
@@ -1531,7 +1837,7 @@ async function processTask(task, authData) {
       conversation: conv
     }, authData, { repoInfo });
   }
-  log4.info("task completed", {
+  log5.info("task completed", {
     sessionId: task.sessionId,
     conversationCount: parsedSession.conversations.length
   });
@@ -1568,12 +1874,12 @@ function getRawDumpUrl(baseUrl, endpoint, isAnonymous = false) {
 async function uploadReport(authData, endpoint, body) {
   const mode = getRawDumpMode();
   if (mode === RAW_DUMP_MODE.DISABLED) {
-    log4.debug(`dump disabled, skipping ${endpoint}`);
+    log5.debug(`dump disabled, skipping ${endpoint}`);
     return;
   }
   const type = endpoint === "/raw-store/task-conversation" ? "conversation" : endpoint === "/raw-store/task-summary" ? "summary" : endpoint === "/raw-store/commit" ? "commit" : endpoint === "/raw-store/statistics" ? "statistics" : endpoint === "/raw-store/raw-log" ? "raw" : "unknown";
   if (type === "unknown") {
-    log4.warn("unknown endpoint, skipping local dump", { endpoint });
+    log5.warn("unknown endpoint, skipping local dump", { endpoint });
   } else if (mode === RAW_DUMP_MODE.LOCAL || mode === RAW_DUMP_MODE.BOTH) {
     await writeLocalDump(type, body);
   }
@@ -1584,10 +1890,10 @@ async function uploadReport(authData, endpoint, body) {
 async function writeRemoteDump(endpoint, authData, body) {
   const isAnonymous = authData.isAnonymous ?? false;
   const url = getRawDumpUrl(authData.baseUrl, endpoint, isAnonymous);
-  log4.debug(`POST ${endpoint}`, { url, authData, isAnonymous });
+  log5.debug(`POST ${endpoint}`, { url, authData, isAnonymous });
   try {
     await postJson(url, body, authData.headers);
-    log4.debug(`POST ${endpoint} ok`);
+    log5.debug(`POST ${endpoint} ok`);
     return;
   } catch (err) {
     throw err instanceof UploadError ? err : new Error(`${endpoint} failed after 3 attempts`);
@@ -1628,18 +1934,18 @@ async function postJson(url, body, headers, maxAttempts = 3) {
       const text = await res.text().catch(() => "");
       lastError = new Error(`${url} failed: ${res.status} ${text}`);
       if (res.status === 429 || res.status >= 500) {
-        log4.warn(`retryable error ${res.status}, will retry`, { url, attempt, status: res.status });
+        log5.warn(`retryable error ${res.status}, will retry`, { url, attempt, status: res.status });
         continue;
       }
       if (res.status === 401 || res.status === 502 || res.status === 503) {
-        log4.warn(`retryable status ${res.status}, will retry`, { url, attempt });
+        log5.warn(`retryable status ${res.status}, will retry`, { url, attempt });
         continue;
       }
       throw lastError;
     } catch (err) {
       lastError = err instanceof Error ? err : new Error(String(err));
       const isAbort = lastError.name === "AbortError";
-      log4.warn(`${isAbort ? "timeout" : "network error"}, will retry`, {
+      log5.warn(`${isAbort ? "timeout" : "network error"}, will retry`, {
         url,
         attempt,
         timeoutMs: REQUEST_TIMEOUT_MS,
@@ -1649,7 +1955,7 @@ async function postJson(url, body, headers, maxAttempts = 3) {
       clearTimeout(timer);
     }
   }
-  log4.error("postJson failed", {
+  log5.error("postJson failed", {
     url,
     headers: headersObj,
     error: lastError?.message
@@ -1679,15 +1985,15 @@ function detectOs() {
 async function auth() {
   let creds = await loadCoStrictCredentials();
   if (!creds?.access_token) {
-    log4.debug("auth: not authenticated");
+    log5.debug("auth: not authenticated");
     throw new Error("Not authenticated");
   }
-  log4.debug("credentials loaded", {
+  log5.debug("credentials loaded", {
     hasRefreshToken: !!creds.refresh_token,
     baseUrl: creds.base_url
   });
   if (creds.refresh_token && !isCoStrictTokenValid(creds)) {
-    log4.debug("token expired, refreshing...");
+    log5.debug("token expired, refreshing...");
     const next = await refreshCoStrictToken({
       baseUrl: creds.base_url || process.env.COSTRICT_BASE_URL || process.env.COSTRICT_RAW_DUMP_BASE_URL || "https://zgsm.sangfor.com",
       refreshToken: creds.refresh_token,
@@ -1706,7 +2012,7 @@ async function auth() {
       access_token: next.access_token,
       refresh_token: next.refresh_token
     };
-    log4.debug("token refreshed");
+    log5.debug("token refreshed");
   }
   const headers = new Headers;
   headers.set("Authorization", `Bearer ${creds.access_token}`);
@@ -1715,8 +2021,8 @@ async function auth() {
   headers.set("X-Title", "CoStrict-CLI");
   let version = "unknown";
   try {
-    const pkgPath = path8.resolve(fileURLToPath(import.meta.url), "../../package.json");
-    const pkg = JSON.parse(await fs8.readFile(pkgPath, "utf-8"));
+    const pkgPath = path11.resolve(fileURLToPath(import.meta.url), "../../package.json");
+    const pkg = JSON.parse(await fs9.readFile(pkgPath, "utf-8"));
     version = pkg.version ?? "unknown";
   } catch {}
   headers.set("X-Costrict-Version", `csc-${version}`);
@@ -1735,7 +2041,7 @@ async function auth() {
   }
   const user = parseUser(accessPayload, refreshPayload);
   const baseUrl = resolveRawDumpBaseUrl(creds.base_url);
-  log4.debug("auth success", {
+  log5.debug("auth success", {
     baseUrl,
     user_id: user.user_id,
     clientId,
@@ -1756,20 +2062,20 @@ async function authWithFallback() {
   } catch (err) {
     let version = "unknown";
     try {
-      const pkgPath = path8.resolve(fileURLToPath(import.meta.url), "../../package.json");
-      const pkg = JSON.parse(await fs8.readFile(pkgPath, "utf-8"));
+      const pkgPath = path11.resolve(fileURLToPath(import.meta.url), "../../package.json");
+      const pkg = JSON.parse(await fs9.readFile(pkgPath, "utf-8"));
       version = pkg.version ?? "unknown";
     } catch {}
     let deviceId = process.env.CSC_DEVICE_ID;
     if (!deviceId) {
-      const deviceIdFile = path8.join(getLocalDumpDir(), "device-id");
+      const deviceIdFile = path11.join(getLocalDumpDir(), "device-id");
       try {
-        deviceId = (await fs8.readFile(deviceIdFile, "utf-8")).trim();
+        deviceId = (await fs9.readFile(deviceIdFile, "utf-8")).trim();
       } catch {}
       if (!deviceId) {
         deviceId = generateMachineId();
         try {
-          await fs8.writeFile(deviceIdFile, deviceId, "utf-8");
+          await fs9.writeFile(deviceIdFile, deviceId, "utf-8");
         } catch {}
       }
       process.env.CSC_DEVICE_ID = deviceId;
@@ -1781,7 +2087,7 @@ async function authWithFallback() {
     headers.set("zgsm-client-ide", "cli");
     headers.set("X-Costrict-Version", `csc-${version}`);
     headers.set("User-Agent", `csc/${version}`);
-    log4.info("auth failed, falling back to anonymous interface", {
+    log5.info("auth failed, falling back to anonymous interface", {
       deviceId,
       version,
       error: err instanceof Error ? err.message : String(err)
@@ -1802,20 +2108,20 @@ async function authWithFallback() {
 async function uploadRaw(sessionId, directory, authData) {
   const normalizedProject = normalizeProjectPath2(directory);
   const stateKey = `${normalizedProject}/${sessionId}`;
-  const filePath = path8.join(CSC_DIR, "projects", normalizedProject, `${sessionId}.jsonl`);
+  const filePath = path11.join(CSC_DIR, "projects", normalizedProject, `${sessionId}.jsonl`);
   const lastReportedCount = state_raw.logs[stateKey] ?? 0;
   let fileContent;
   try {
-    fileContent = await fs8.readFile(filePath, "utf-8");
+    fileContent = await fs9.readFile(filePath, "utf-8");
   } catch (err) {
-    log4.warn("raw file not found, skip", { filePath });
+    log5.warn("raw file not found, skip", { filePath });
     return;
   }
   const lines = fileContent.split(`
 `).filter((line) => line.trim());
   const newLines = lines.slice(lastReportedCount);
   if (newLines.length === 0) {
-    log4.debug("raw no new data", { stateKey, lastReportedCount, total: lines.length });
+    log5.debug("raw no new data", { stateKey, lastReportedCount, total: lines.length });
     return;
   }
   const events = [];
@@ -1826,7 +2132,7 @@ async function uploadRaw(sessionId, directory, authData) {
     } catch {}
   }
   if (events.length === 0) {
-    log4.warn("raw no valid events", { stateKey });
+    log5.warn("raw no valid events", { stateKey });
     return;
   }
   const BATCH_SIZE = 50;
@@ -1843,19 +2149,19 @@ async function uploadRaw(sessionId, directory, authData) {
     };
     await uploadReport(authData, "/raw-store/raw-log", body);
     offset += BATCH_SIZE;
-    log4.debug("raw batch uploaded", { stateKey, batchOffset: offset, batchSize: batch.length });
+    log5.debug("raw batch uploaded", { stateKey, batchOffset: offset, batchSize: batch.length });
   }
   state_raw.logs[stateKey] = lastReportedCount + newLines.length;
   state_raw.total = Object.keys(state_raw.logs).length;
   await saveRaw();
-  log4.info("raw uploaded", { stateKey, count: events.length });
+  log5.info("raw uploaded", { stateKey, count: events.length });
 }
 async function uploadConversation(payload, authData, options) {
   const conv = payload.conversation;
   const requestID = conv.id;
   const key = `${payload.sessionId}:${requestID}`;
   if (state_conv.conversation[key]) {
-    log4.info("conversation skipped: already uploaded", {
+    log5.info("conversation skipped: already uploaded", {
       task_id: payload.sessionId,
       request_id: requestID,
       last_reported: state_conv.conversation[key]
@@ -1863,7 +2169,7 @@ async function uploadConversation(payload, authData, options) {
     return false;
   }
   if (state_conv.clean_time && payload.conversation.startTime && payload.conversation.startTime.getTime() < new Date(state_conv.clean_time).getTime()) {
-    log4.info("conversation skipped: too old", {
+    log5.info("conversation skipped: too old", {
       task_id: payload.sessionId,
       request_id: requestID,
       clean_time: state_conv.clean_time,
@@ -1876,18 +2182,21 @@ async function uploadConversation(payload, authData, options) {
   const diffLines = rawDiff ? countDiffLines(rawDiff) : 0;
   const files = conv.diffs.map((d) => d.file);
   const repoInfo = options?.repoInfo ?? await getRepoInfo(payload.directory);
+  const gitRoot = repoInfo.git_root ?? "";
   const body = {
     task_id: payload.sessionId,
     request_id: requestID,
-    prompt_mode: "",
+    prompt_mode: conv.promptMode,
     mode: "code",
-    model: "",
+    model: conv.model,
     start_time: formatIso(conv.startTime),
     end_time: formatIso(conv.endTime),
     process_time: conv.duration,
     process_ttft: 0,
-    upstream_tokens: conv.inputTokens,
+    upstream_tokens: conv.inputTokens + conv.cacheReadInputTokens + conv.cacheCreationInputTokens,
     downstream_tokens: conv.outputTokens,
+    cache_read_tokens: conv.cacheReadInputTokens,
+    cache_creation_tokens: conv.cacheCreationInputTokens,
     cost: 0,
     sender: conv.sender,
     request_content: conv.requestContent,
@@ -1898,11 +2207,14 @@ async function uploadConversation(payload, authData, options) {
     diff: rawDiff,
     diff_lines: diffLines,
     files,
+    tool_events: capToolEventsPayload(conv.toolEvents),
     repo_addr: repoInfo.repo_addr,
     repo_branch: repoInfo.repo_branch,
-    work_dir: payload.directory
+    work_dir: payload.directory,
+    git_root: gitRoot,
+    repo_relative_path: computeRepoRelativePath(gitRoot, payload.directory)
   };
-  log4.debug("conversation uploading", {
+  log5.debug("conversation uploading", {
     task_id: payload.sessionId,
     request_id: requestID
   });
@@ -1913,7 +2225,7 @@ async function uploadConversation(payload, authData, options) {
   if (wasIncomplete)
     state_conv.incomplete--;
   await saveConversation();
-  log4.info("conversation uploaded", {
+  log5.info("conversation uploaded", {
     task_id: payload.sessionId,
     request_id: requestID,
     upstream_tokens: body.upstream_tokens,
@@ -1923,12 +2235,12 @@ async function uploadConversation(payload, authData, options) {
 }
 async function uploadSummary(payload, authData) {
   const parsed = payload.parsedSession;
-  log4.debug("uploadSummary start", {
+  log5.debug("uploadSummary start", {
     sessionId: payload.sessionId,
     conversationCount: parsed.conversations.length
   });
   if (state_summary.summary[payload.sessionId]) {
-    log4.info("summary skipped: already uploaded", {
+    log5.info("summary skipped: already uploaded", {
       task_id: payload.sessionId
     });
     return;
@@ -1936,7 +2248,7 @@ async function uploadSummary(payload, authData) {
   const firstConv = parsed.conversations[0];
   const startTime = firstConv?.userEvent.timestamp ? new Date(firstConv.userEvent.timestamp) : new Date(Date.now());
   if (state_summary.clean_time && startTime < new Date(state_summary.clean_time)) {
-    log4.info("summary skipped: too old", {
+    log5.info("summary skipped: too old", {
       startTime: startTime.toISOString(),
       clean_time: state_summary.clean_time
     });
@@ -1960,12 +2272,12 @@ async function uploadSummary(payload, authData) {
   if (wasIncomplete)
     state_summary.incomplete--;
   await saveSummary();
-  log4.info("summary uploaded", { task_id: payload.sessionId });
+  log5.info("summary uploaded", { task_id: payload.sessionId });
 }
 async function uploadCommits(directory, authData, options) {
   const repoInfo = options?.repoInfo ?? await getRepoInfo(directory);
   if (!repoInfo.repo_addr || !repoInfo.repo_branch) {
-    log4.info("commits skipped: missing repo info", {
+    log5.info("commits skipped: missing repo info", {
       work_dir: directory,
       repo_addr: repoInfo.repo_addr,
       repo_branch: repoInfo.repo_branch
@@ -1978,7 +2290,7 @@ async function uploadCommits(directory, authData, options) {
   const allCommits = parseCommitLog(logText);
   const commits = allCommits.slice(0, 50);
   if (!commits.length) {
-    log4.info("commits skipped: no new commits", {
+    log5.info("commits skipped: no new commits", {
       stateKey,
       lastCommit: lastCommit || "",
       total: allCommits.length,
@@ -1986,7 +2298,7 @@ async function uploadCommits(directory, authData, options) {
     });
     return 0;
   }
-  log4.debug("parsed commits", {
+  log5.debug("parsed commits", {
     stateKey,
     lastCommit: lastCommit || "",
     total: allCommits.length,
@@ -1994,6 +2306,9 @@ async function uploadCommits(directory, authData, options) {
   });
   const originalLastCommit = state_commit.commits[stateKey] || "";
   let uploadedCount = 0;
+  const gitRoot = repoInfo.git_root ?? "";
+  const repoRelativePath = computeRepoRelativePath(gitRoot, directory);
+  const { base_branch, fork_point } = await getBranchAncestry(directory);
   try {
     for (let i = 0;i < commits.length; i++) {
       const commit = commits[i];
@@ -2001,6 +2316,8 @@ async function uploadCommits(directory, authData, options) {
         await new Promise((r) => setTimeout(r, 500));
       }
       const diff = await getCommitDiff(directory, commit.commit_id);
+      const commitTimeMs = Date.parse(commit.commit_time);
+      const activeSessionIds = getActiveSessionIds(directory, Number.isNaN(commitTimeMs) ? undefined : commitTimeMs);
       const body = {
         commit_id: commit.commit_id,
         commit_time: commit.commit_time,
@@ -2013,6 +2330,11 @@ async function uploadCommits(directory, authData, options) {
         client_version: authData.version,
         client_ide: "cli",
         work_dir: directory,
+        git_root: gitRoot,
+        repo_relative_path: repoRelativePath,
+        base_branch,
+        fork_point,
+        active_session_ids: activeSessionIds,
         diff_lines: countDiffLines(diff),
         diff,
         files: extractFilesFromDiff(diff),
@@ -2024,7 +2346,7 @@ async function uploadCommits(directory, authData, options) {
       uploadedCount++;
       state_commit.commits[stateKey] = commit.commit_id;
       await saveCommits();
-      log4.info("commit uploaded", {
+      log5.info("commit uploaded", {
         commit_id: commit.commit_id,
         progress: `${i + 1}/${commits.length}`
       });
@@ -2032,7 +2354,7 @@ async function uploadCommits(directory, authData, options) {
   } catch (err) {
     state_commit.commits[stateKey] = originalLastCommit;
     await saveCommits();
-    log4.error("commit batch failed, rolled back", {
+    log5.error("commit batch failed, rolled back", {
       work_dir: directory,
       uploadedCount,
       error: err instanceof Error ? err.message : String(err)
@@ -2065,7 +2387,7 @@ async function uploadStatistics(authData) {
     state_statistics.statistics[k].currentUploadAt = timestamp;
     state_statistics.incomplete--;
     await saveStatistics();
-    log4.info("statistics uploaded", {
+    log5.info("statistics uploaded", {
       k,
       session_count: daily.sessionCount,
       conversation_count: daily.conversationCount,
@@ -2087,7 +2409,7 @@ async function processIncompleteTasks(authData) {
       await saveTasks();
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
-      log4.error("task failed", {
+      log5.error("task failed", {
         error: errorMsg,
         task: record
       });
@@ -2108,7 +2430,7 @@ async function processIncompleteTasks(authData) {
         state_task.tasks[key].uploadedAt = "DEAD_LETTER";
         state_task.incomplete--;
         await saveTasks();
-        log4.error("task moved to dead letter", {
+        log5.error("task moved to dead letter", {
           key,
           attemptCount: state_task.tasks[key].attemptCount
         });
@@ -2118,9 +2440,9 @@ async function processIncompleteTasks(authData) {
 }
 async function runHistorySessionWorker() {
   try {
-    log4.info("history session start");
+    log5.info("history session start");
     const items = await autoLoadHistory();
-    log4.info("history session loaded: ", { length: items ? items.length : 0 });
+    log5.info("history session loaded: ", { length: items ? items.length : 0 });
     const seen = new Map;
     for (const item of items ?? []) {
       const key = `${item.sessionId}:${item.project}`;
@@ -2135,29 +2457,29 @@ async function runHistorySessionWorker() {
         await uploadRaw(item.sessionId, item.project, authData);
         rawCount++;
       } catch (err) {
-        log4.warn("uploadRaw failed", { sessionId: item.sessionId, project: item.project, error: err instanceof Error ? err.message : String(err) });
+        log5.warn("uploadRaw failed", { sessionId: item.sessionId, project: item.project, error: err instanceof Error ? err.message : String(err) });
       }
     }
-    log4.info("history session upload done", { count: rawCount });
+    log5.info("history session upload done", { count: rawCount });
   } catch (err) {
-    log4.error("history session failed", {
+    log5.error("history session failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
 }
 async function runRawDumpWorker() {
-  log4.info("WORKER start");
+  log5.info("WORKER start");
   try {
     await loadAllState();
     await runHistorySessionWorker();
     await runCommitTimer();
     await runStatisticsTimer();
   } catch (err) {
-    log4.error("WORKER failed", {
+    log5.error("WORKER failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
-  log4.info("WORKER end");
+  log5.info("WORKER end");
 }
 var COMMIT_INTERVAL_MS = 5 * 60 * 1000;
 var STATS_INTERVAL_MS = 60 * 60 * 1000;
@@ -2177,80 +2499,80 @@ async function runCommitTimer() {
   if (now - lastCommitRun < COMMIT_INTERVAL_MS)
     return;
   lastCommitRun = now;
-  log4.debug("commit timer firing");
+  log5.debug("commit timer firing");
   const dirs = await getProjectDirs();
-  log4.debug("scanned project dirs", { count: dirs.length });
+  log5.debug("scanned project dirs", { count: dirs.length });
   const authData = await authWithFallback();
   for (const dir of dirs) {
     try {
       const repoInfo = await getCachedRepoInfo(dir);
       if (!repoInfo.repo_addr || !repoInfo.repo_branch) {
-        log4.debug("skip dir: missing repo info", { dir });
+        log5.debug("skip dir: missing repo info", { dir });
         continue;
       }
       await uploadCommits(dir, authData, { repoInfo });
     } catch (err) {
-      log4.error("commit timer failed for dir", {
+      log5.error("commit timer failed for dir", {
         dir,
         error: err instanceof Error ? err.message : String(err)
       });
     }
   }
-  log4.debug("commit timer done");
+  log5.debug("commit timer done");
 }
 async function runStatisticsTimer() {
   const now = Date.now();
   if (now - lastStatsRun < STATS_INTERVAL_MS)
     return;
   lastStatsRun = now;
-  log4.debug("statistics timer firing");
+  log5.debug("statistics timer firing");
   try {
     const authData = await authWithFallback();
     await uploadStatistics(authData);
   } catch (err) {
-    log4.error("statistics timer failed", {
+    log5.error("statistics timer failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
-  log4.debug("statistics timer done");
+  log5.debug("statistics timer done");
 }
 async function runQueueTimer() {
   const now = Date.now();
   if (now - lastQueueRun < QUEUE_INTERVAL_MS)
     return;
   lastQueueRun = now;
-  log4.debug("queue timer firing");
+  log5.debug("queue timer firing");
   if (!await acquireQueueLock()) {
-    log4.debug("another worker process holds the lock, skip");
+    log5.debug("another worker process holds the lock, skip");
     return;
   }
   try {
     const newTasks = getQueue();
     if (newTasks.length === 0) {
       if (state_task.incomplete === 0) {
-        log4.debug("queue empty, no incomplete tasks");
+        log5.debug("queue empty, no incomplete tasks");
         return;
       }
-      log4.debug("queue empty, but has incomplete tasks in state");
+      log5.debug("queue empty, but has incomplete tasks in state");
     }
-    log4.info(`processing ${newTasks.length} new tasks`);
+    log5.info(`processing ${newTasks.length} new tasks`);
     addQueueTasks(newTasks);
     await saveTasks();
     clearQueue();
   } catch (err) {
-    log4.error("queue timer failed", {
+    log5.error("queue timer failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   } finally {
     await releaseQueueLock();
   }
-  log4.info(`tracking ${state_task.total} tasks total, ${state_task.incomplete} incomplete`);
+  log5.info(`tracking ${state_task.total} tasks total, ${state_task.incomplete} incomplete`);
   try {
     const authData = await authWithFallback();
     await processIncompleteTasks(authData);
-    log4.info("queue timer completed");
+    log5.info("queue timer completed");
   } catch (err) {
-    log4.error("queue timer failed, queue retained", {
+    log5.error("queue timer failed, queue retained", {
       error: err instanceof Error ? err.message : String(err)
     });
     throw err;
@@ -2264,38 +2586,25 @@ if (scriptPath.endsWith("worker.ts") || scriptPath.endsWith("worker.js")) {
 }
 
 // src/services/rawDump/timerWorker.ts
-import { promises as fs9 } from "fs";
-import path9 from "path";
-var log5 = createLogger("timer");
-var TIMER_LOCK_FILE = path9.join(getRawDumpDir(), "csc-timer.lock");
+import path12 from "path";
+var log6 = createLogger("timer");
+var TIMER_LOCK_DIR = path12.join(getRawDumpDir(), "csc-timer.lock.d");
 var isRunning = false;
 async function acquireTimerLock() {
-  try {
-    const stat2 = await fs9.readFile(TIMER_LOCK_FILE, "utf-8").catch(() => "");
-    const pid = parseInt(stat2.trim(), 10);
-    if (!isNaN(pid) && pid !== process.pid) {
-      try {
-        process.kill(pid, 0);
-        return false;
-      } catch {}
-    }
-    await fs9.writeFile(TIMER_LOCK_FILE, String(process.pid), "utf-8");
-    return true;
-  } catch {
-    return false;
-  }
+  return acquireLock(TIMER_LOCK_DIR, {
+    pid: process.pid,
+    startedAt: new Date().toISOString()
+  });
 }
 async function releaseTimerLock() {
-  try {
-    await fs9.writeFile(TIMER_LOCK_FILE, "", "utf-8");
-  } catch {}
+  await releaseLock(TIMER_LOCK_DIR);
 }
 async function runTimers() {
   if (isRunning)
     return;
   isRunning = true;
   if (!await acquireTimerLock()) {
-    log5.debug("another timer worker holds the lock, skip");
+    log6.debug("another timer worker holds the lock, skip");
     isRunning = false;
     return;
   }
@@ -2304,7 +2613,7 @@ async function runTimers() {
     await runCommitTimer();
     await runStatisticsTimer();
   } catch (err) {
-    log5.error("timer worker error", {
+    log6.error("timer worker error", {
       error: err instanceof Error ? err.message : String(err)
     });
   } finally {
@@ -2317,7 +2626,7 @@ function scheduleNext() {
     try {
       await runTimers();
     } catch (err) {
-      log5.error("runTimers threw", {
+      log6.error("runTimers threw", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -2325,12 +2634,12 @@ function scheduleNext() {
   }, 60000);
 }
 function startTimerWorker() {
-  log5.info("timer worker starting", getTimerIntervals());
+  log6.info("timer worker starting", getTimerIntervals());
   setImmediate(async () => {
     try {
       await runTimers();
     } catch (err) {
-      log5.error("initial timer run failed", {
+      log6.error("initial timer run failed", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -2343,7 +2652,24 @@ if (scriptPath2.endsWith("timerWorker.ts") || scriptPath2.endsWith("timerWorker.
 }
 
 // src/services/rawDump/batchWorker.ts
-var log6 = createLogger("batch");
+var log7 = createLogger("batch");
+var shuttingDown = false;
+function scheduleForcedExit(reason, code) {
+  if (shuttingDown)
+    return;
+  shuttingDown = true;
+  log7.info("shutdown signal received, scheduling forced exit after grace period", { reason, workerPid: process.pid });
+  const graceMs = 1e4;
+  setTimeout(() => {
+    log7.warn("grace period expired, forcing exit");
+    process.exit(code);
+  }, graceMs);
+}
+process.on("SIGTERM", () => scheduleForcedExit("SIGTERM", 0));
+process.on("SIGINT", () => scheduleForcedExit("SIGINT", 0));
+process.on("unhandledRejection", (reason) => {
+  log7.error("unhandled rejection", { reason: String(reason), workerPid: process.pid });
+});
 var PARENT_PID = process.ppid;
 var IS_WORKER_PROCESS = process.argv[1]?.includes("batchWorker") || false;
 function isParentAlive() {
@@ -2358,17 +2684,17 @@ function isParentAlive() {
 }
 var stateLoaded = false;
 function startBatchWorker() {
-  log6.info("batch worker started");
+  log7.info("batch worker started");
   loadAllState().then(() => {
     stateLoaded = true;
   }).catch((err) => {
-    log6.error("failed to load state", {
+    log7.error("failed to load state", {
       error: err instanceof Error ? err.message : String(err)
     });
     process.exit(1);
   });
   loadQueue().catch((err) => {
-    log6.error("failed to load queue", {
+    log7.error("failed to load queue", {
       error: err instanceof Error ? err.message : String(err)
     });
     process.exit(1);
@@ -2377,7 +2703,7 @@ function startBatchWorker() {
     try {
       await runHistorySessionWorker();
     } catch (err) {
-      log6.error("runHistorySessionWorker failed", {
+      log7.error("runHistorySessionWorker failed", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -2389,7 +2715,7 @@ function startParentWatchdog() {
   if (!IS_WORKER_PROCESS)
     return;
   const intervalMs = 5000;
-  const maxParentGoneAliveMs = 60000;
+  const maxParentGoneAliveMs = 1e4;
   let parentGoneAt = null;
   setInterval(() => {
     if (isParentAlive()) {
@@ -2403,7 +2729,7 @@ function startParentWatchdog() {
     const canExitSafely = stateLoaded && state_task.incomplete === 0;
     const graceExpired = goneMs >= maxParentGoneAliveMs;
     if (canExitSafely || graceExpired) {
-      log6.info("parent process gone, exiting batch worker", {
+      log7.info("parent process gone, exiting batch worker", {
         parentPid: PARENT_PID,
         workerPid: process.pid,
         reason: canExitSafely ? "no incomplete tasks" : "grace period expired",
@@ -2422,5 +2748,5 @@ export {
   startBatchWorker
 };
 
-//# debugId=56D185F86C6BF97E64756E2164756E21
+//# debugId=5E38E5DD30FE370364756E2164756E21
 //# sourceMappingURL=batchWorker.js.map