@costrict/csc 4.1.10 → 4.1.11

package/dist/services/rawDump/batchWorker.js

@@ -3,21 +3,57 @@ var __require = typeof import.meta.require === "function" ? import.meta.require
 
 // src/services/rawDump/state.ts
 import { promises as fs, readFileSync, writeFileSync } from "fs";
+import os2 from "os";
+import path2 from "path";
+
+// src/services/rawDump/logger.ts
+import { appendFileSync } from "fs";
 import os from "os";
 import path from "path";
-var STATE_DIR = path.join(os.homedir(), ".claude", "raw-dump");
-var CONVERSATION_FILE = path.join(STATE_DIR, "csc-conversation.json");
-var SUMMARY_FILE = path.join(STATE_DIR, "csc-summary.json");
-var COMMITS_FILE = path.join(STATE_DIR, "csc-commits.json");
-var STATISTICS_FILE = path.join(STATE_DIR, "csc-statistics.json");
-var TASKS_FILE = path.join(STATE_DIR, "csc-tasks.json");
-var DEAD_LETTER_FILE = path.join(STATE_DIR, "csc-dead-letter.jsonl");
-var STATE_LOCK_FILE = path.join(STATE_DIR, "csc-state.lock");
-var state_conv = { conversation: {}, total: 0, incomplete: 0 };
-var state_summary = { summary: {}, total: 0, incomplete: 0 };
-var state_commit = { commits: {}, total: 0, incomplete: 0 };
-var state_statistics = { statistics: {}, total: 0, incomplete: 0 };
-var state_task = { tasks: {}, total: 0, incomplete: 0 };
+var LOG_FILE = path.join(os.homedir(), ".claude", "raw-dump", "csc-raw-dump.log");
+function isDebugEnabled() {
+  const v = process.env.CSC_RAW_DUMP_DEBUG;
+  return v === "1" || v === "true";
+}
+function createLogger(prefix) {
+  const enabled = isDebugEnabled();
+  function write(level, msg, meta) {
+    const alwaysWrite = level === "error" || level === "warn";
+    if (!alwaysWrite && !enabled)
+      return;
+    const timestamp = new Date().toISOString();
+    const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+    const line = `[${timestamp}] [${prefix}:${level}] ${msg}${metaStr}
+`;
+    console.error(line.trimEnd());
+    try {
+      appendFileSync(LOG_FILE, line);
+    } catch {}
+  }
+  const log = Object.assign((level, msg, meta) => write(level, msg, meta), {
+    debug: (msg, meta) => write("debug", msg, meta),
+    info: (msg, meta) => write("info", msg, meta),
+    warn: (msg, meta) => write("warn", msg, meta),
+    error: (msg, meta) => write("error", msg, meta)
+  });
+  return log;
+}
+
+// src/services/rawDump/state.ts
+var log = createLogger("state");
+var STATE_DIR = path2.join(os2.homedir(), ".claude", "raw-dump");
+var CONVERSATION_FILE = path2.join(STATE_DIR, "csc-conversation.json");
+var SUMMARY_FILE = path2.join(STATE_DIR, "csc-summary.json");
+var COMMITS_FILE = path2.join(STATE_DIR, "csc-commits.json");
+var STATISTICS_FILE = path2.join(STATE_DIR, "csc-statistics.json");
+var TASKS_FILE = path2.join(STATE_DIR, "csc-tasks.json");
+var DEAD_LETTER_FILE = path2.join(STATE_DIR, "csc-dead-letter.jsonl");
+var STATE_LOCK_FILE = path2.join(STATE_DIR, "csc-state.lock");
+var state_conv = { conversation: {}, clean_time: "", total: 0, incomplete: 0 };
+var state_summary = { summary: {}, clean_time: "", total: 0, incomplete: 0 };
+var state_commit = { commits: {}, clean_time: "", total: 0, incomplete: 0 };
+var state_statistics = { statistics: {}, clean_time: "", total: 0, incomplete: 0 };
+var state_task = { tasks: {}, history_cursor: -1, total: 0, incomplete: 0 };
 function readLockInfo(lockPath) {
   try {
     const content = readFileSync(lockPath, "utf-8").trim();
@@ -91,64 +127,112 @@ async function withStateLock(fn) {
     releaseStateLock();
   }
 }
-function cleanupOldRecords() {
-  const yesterday = new Date;
-  yesterday.setDate(yesterday.getDate() - 1);
-  yesterday.setHours(0, 0, 0, 0);
-  const yesterdayMs = yesterday.getTime();
+function cleanupOldConvs(clean_ts) {
   const cleanedConv = {};
   let incompleteConv = 0;
+  let cleanCount = 0;
   for (const [k, ts] of Object.entries(state_conv.conversation)) {
     if (!ts) {
       incompleteConv++;
       cleanedConv[k] = ts;
-    } else if (new Date(ts).getTime() >= yesterdayMs) {
+    } else if (new Date(ts).getTime() >= clean_ts) {
       cleanedConv[k] = ts;
+    } else {
+      cleanCount++;
     }
   }
+  if (cleanCount > 0) {
+    state_conv.clean_time = new Date(clean_ts).toISOString();
+    log.info("cleanup conversation", { clean_count: cleanCount, clean_time: state_conv.clean_time });
+  }
   state_conv.conversation = cleanedConv;
   state_conv.incomplete = incompleteConv;
   state_conv.total = Object.keys(cleanedConv).length;
+}
+function cleanupOldSummarys(clean_ts) {
   const cleanedSum = {};
   let incompleteSum = 0;
+  let cleanCount = 0;
   for (const [k, ts] of Object.entries(state_summary.summary)) {
     if (!ts) {
       incompleteSum++;
       cleanedSum[k] = ts;
-    } else if (new Date(ts).getTime() >= yesterdayMs) {
+    } else if (new Date(ts).getTime() >= clean_ts) {
       cleanedSum[k] = ts;
+    } else {
+      cleanCount++;
     }
   }
+  if (cleanCount > 0) {
+    state_summary.clean_time = new Date(clean_ts).toISOString();
+    log.info("cleanup summary", { clean_count: cleanCount, clean_time: state_summary.clean_time });
+  }
   state_summary.summary = cleanedSum;
   state_summary.incomplete = incompleteSum;
   state_summary.total = Object.keys(cleanedSum).length;
+}
+function cleanupOldTasks(clean_ts) {
   const cleanedTasks = {};
   let incompleteTasks = 0;
+  let history_cursor = -1;
+  let cleanCount = 0;
   for (const [k, r] of Object.entries(state_task.tasks)) {
     if (!r.uploadedAt) {
       incompleteTasks++;
       cleanedTasks[k] = r;
-    } else if (new Date(r.uploadedAt).getTime() >= yesterdayMs) {
+    } else if (new Date(r.uploadedAt).getTime() >= clean_ts) {
       cleanedTasks[k] = r;
+    } else {
+      cleanCount++;
+      if (r.historyNo ?? -1 > history_cursor) {
+        history_cursor = r.historyNo;
+      }
     }
   }
+  if (history_cursor >= 0) {
+    state_task.history_cursor = history_cursor;
+    log.info("cleanup task", {
+      clean_count: cleanCount,
+      history_cursor,
+      clean_time: new Date(clean_ts).toISOString()
+    });
+  }
   state_task.tasks = cleanedTasks;
   state_task.incomplete = incompleteTasks;
   state_task.total = Object.keys(cleanedTasks).length;
+}
+function cleanupOldStats(clean_ts) {
   const cleanedStats = {};
   let incompleteStat = 0;
+  let cleanCount = 0;
   for (const [k, ts] of Object.entries(state_statistics.statistics)) {
     if (!ts.currentUploadAt) {
       cleanedStats[k] = ts;
       incompleteStat++;
-    } else if (new Date(k).getTime() >= yesterdayMs) {
+    } else if (new Date(k).getTime() >= clean_ts) {
       cleanedStats[k] = ts;
+    } else {
+      cleanCount++;
     }
   }
+  if (cleanCount > 0) {
+    state_statistics.clean_time = new Date(clean_ts).toISOString();
+    log.info("cleanup statistics", { clean_count: cleanCount, clean_time: state_statistics.clean_time });
+  }
   state_statistics.statistics = cleanedStats;
   state_statistics.total = Object.keys(cleanedStats).length;
   state_statistics.incomplete = incompleteStat;
 }
+function cleanupOldRecords() {
+  const yesterday = new Date;
+  yesterday.setDate(yesterday.getDate() - 1);
+  yesterday.setHours(0, 0, 0, 0);
+  const yesterdayMs = yesterday.getTime();
+  cleanupOldConvs(yesterdayMs);
+  cleanupOldSummarys(yesterdayMs);
+  cleanupOldTasks(yesterdayMs);
+  cleanupOldStats(yesterdayMs);
+}
 async function loadAllState() {
   await Promise.all([
     loadConversation(),
@@ -166,11 +250,12 @@ async function loadConversation() {
       const parsed = JSON.parse(text);
       state_conv = {
         conversation: parsed.conversation ?? {},
+        clean_time: parsed.clean_time ?? "",
         total: Object.keys(parsed.conversation ?? {}).length,
         incomplete: Object.values(parsed.conversation ?? {}).filter((ts) => !ts).length
       };
     } catch {
-      state_conv = { conversation: {}, total: 0, incomplete: 0 };
+      state_conv = { conversation: {}, clean_time: "", total: 0, incomplete: 0 };
     }
   });
 }
@@ -181,11 +266,12 @@ async function loadSummary() {
       const parsed = JSON.parse(text);
       state_summary = {
         summary: parsed.summary ?? {},
+        clean_time: parsed.clean_time ?? "",
         total: Object.keys(parsed.summary ?? {}).length,
         incomplete: Object.values(parsed.summary ?? {}).filter((ts) => !ts).length
       };
     } catch {
-      state_summary = { summary: {}, total: 0, incomplete: 0 };
+      state_summary = { summary: {}, clean_time: "", total: 0, incomplete: 0 };
     }
   });
 }
@@ -196,11 +282,12 @@ async function loadCommits() {
       const parsed = JSON.parse(text);
       state_commit = {
         commits: parsed.commits ?? {},
+        clean_time: parsed.clean_time ?? "",
         total: Object.keys(parsed.commits ?? {}).length,
         incomplete: 0
       };
     } catch {
-      state_commit = { commits: {}, total: 0, incomplete: 0 };
+      state_commit = { commits: {}, clean_time: "", total: 0, incomplete: 0 };
     }
   });
 }
@@ -211,11 +298,12 @@ async function loadStatistics() {
       const parsed = JSON.parse(text);
       state_statistics = {
         statistics: parsed.statistics ?? {},
+        clean_time: parsed.clean_time ?? "",
         total: Object.keys(parsed.statistics ?? {}).length,
         incomplete: Object.values(parsed.statistics ?? {}).filter((ts) => !ts.currentUploadAt).length
       };
     } catch {
-      state_statistics = { statistics: {}, total: 0, incomplete: 0 };
+      state_statistics = { statistics: {}, clean_time: "", total: 0, incomplete: 0 };
     }
   });
 }
@@ -227,11 +315,12 @@ async function loadTasks() {
       const tasks = parsed.tasks ?? {};
       state_task = {
         tasks,
+        history_cursor: parsed.history_cursor ?? -1,
         total: Object.keys(tasks).length,
         incomplete: Object.values(tasks).filter((r) => !r.uploadedAt).length
       };
     } catch {
-      state_task = { tasks: {}, total: 0, incomplete: 0 };
+      state_task = { tasks: {}, history_cursor: -1, total: 0, incomplete: 0 };
     }
   });
 }
@@ -261,7 +350,7 @@ async function saveCommits() {
 async function saveStatistics() {
   return withStateLock(async () => {
     await fs.mkdir(STATE_DIR, { recursive: true });
-    state_statistics.incomplete = Object.values(state_statistics.statistics).filter((ts) => !ts).length;
+    state_statistics.incomplete = Object.values(state_statistics.statistics).filter((r) => !r.currentUploadAt).length;
     state_statistics.total = Object.keys(state_statistics.statistics).length;
     await fs.writeFile(STATISTICS_FILE, JSON.stringify(state_statistics, null, 2), "utf-8");
   });
@@ -297,9 +386,9 @@ function addQueueTasks(tasks) {
     }
   }
 }
-function addHistoryTasks(startNo, tasks) {
+function addHistoryTasks(tasks) {
   const seen = new Map;
-  for (let i = 0;i < tasks.length; i++) {
+  for (let i = state_task.history_cursor + 1;i < tasks.length; i++) {
     const item = tasks[i];
     const key = `${item.sessionId}`;
     const existing = seen.get(key);
@@ -308,7 +397,7 @@ function addHistoryTasks(startNo, tasks) {
     }
   }
   for (const { item, index } of seen.values()) {
-    const historyNo = startNo + index;
+    const historyNo = index;
     const key = `${item.sessionId}:history-${historyNo}`;
     const existing = state_task.tasks[key];
     if (!existing) {
@@ -352,10 +441,10 @@ function getCoStrictCredentialsPath() {
   return join(COSTRICT_CONFIG_DIR, "auth.json");
 }
 function generateMachineId() {
-  const os2 = __require("os");
-  const platform = os2.platform();
-  const hostname = os2.hostname();
-  const username = os2.userInfo().username;
+  const os3 = __require("os");
+  const platform = os3.platform();
+  const hostname = os3.hostname();
+  const username = os3.userInfo().username;
   const machineInfo = `${platform}-${hostname}-${username}`;
   return createHash("sha256").update(machineInfo).digest("hex");
 }
@@ -388,8 +477,8 @@ async function saveCoStrictCredentials(credentials) {
 import { createRequire } from "module";
 function getVersion() {
   try {
-    if (typeof MACRO !== "undefined" && "4.1.10")
-      return "4.1.10";
+    if (typeof MACRO !== "undefined" && "4.1.11")
+      return "4.1.11";
   } catch {}
   try {
     const require2 = createRequire(import.meta.url);
@@ -586,39 +675,6 @@ function toCommitComment(subject) {
   return Array.from(subject).slice(0, 150).join("");
 }
 
-// src/services/rawDump/logger.ts
-import { appendFileSync } from "fs";
-import os2 from "os";
-import path2 from "path";
-var LOG_FILE = path2.join(os2.homedir(), ".claude", "raw-dump", "csc-raw-dump.log");
-function isDebugEnabled() {
-  const v = process.env.CSC_RAW_DUMP_DEBUG;
-  return v === "1" || v === "true";
-}
-function createLogger(prefix) {
-  const enabled = isDebugEnabled();
-  function write(level, msg, meta) {
-    const alwaysWrite = level === "error" || level === "warn";
-    if (!alwaysWrite && !enabled)
-      return;
-    const timestamp = new Date().toISOString();
-    const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
-    const line = `[${timestamp}] [${prefix}:${level}] ${msg}${metaStr}
-`;
-    console.error(line.trimEnd());
-    try {
-      appendFileSync(LOG_FILE, line);
-    } catch {}
-  }
-  const log = Object.assign((level, msg, meta) => write(level, msg, meta), {
-    debug: (msg, meta) => write("debug", msg, meta),
-    info: (msg, meta) => write("info", msg, meta),
-    warn: (msg, meta) => write("warn", msg, meta),
-    error: (msg, meta) => write("error", msg, meta)
-  });
-  return log;
-}
-
 // src/services/rawDump/localStorage.ts
 import { promises as fs3 } from "fs";
 import os3 from "os";
@@ -643,23 +699,67 @@ function getRawDumpMode() {
     return 3;
   return 1;
 }
+function normalizeProjectPath(dir) {
+  return dir.replace(/:/g, "-").replace(/[/\\]/g, "-");
+}
+function getDateFromTimestamp(ts) {
+  const d = new Date(ts);
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${year}/${month}/${day}`;
+}
+function getTimestampField(type, body) {
+  if (type === "commit")
+    return body.commit_time;
+  return body.start_time;
+}
 async function writeLocalDump(type, body) {
   const dir = getLocalDumpDir();
-  const taskId = body.task_id || body.commit_id || "unknown";
-  const taskDir = path3.join(dir, type, taskId);
-  await fs3.mkdir(taskDir, { recursive: true });
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, -5);
-  const requestId = body.request_id || body.commit_id || body.task_id || "unknown";
-  const filename = `${timestamp}-${requestId}.json`;
-  const filePath = path3.join(taskDir, filename);
+  let subdir = "";
+  let ymd = "";
+  let fname = "";
+  let endpoint = "";
+  if (type == "summary") {
+    ymd = getDateFromTimestamp(getTimestampField("summary", body));
+    subdir = ymd;
+    fname = body.task_id;
+    endpoint = "/raw-store/task-summary";
+  } else if (type == "conversation") {
+    ymd = getDateFromTimestamp(getTimestampField("conversation", body));
+    subdir = path3.join(ymd, body.task_id);
+    fname = body.request_id;
+    endpoint = "/raw-store/task-conversation";
+  } else if (type == "commit") {
+    ymd = getDateFromTimestamp(getTimestampField("commit", body));
+    subdir = path3.join(normalizeProjectPath(body.repo_addr), normalizeProjectPath(body.repo_branch), ymd);
+    fname = body.commit_id;
+    endpoint = "/raw-store/commit";
+  } else if (type == "statistics") {
+    subdir = getDateFromTimestamp(getTimestampField("statistics", body));
+    const t = new Date(body.end_time);
+    const h = String(t.getHours()).padStart(2, "0");
+    const m = String(t.getMinutes()).padStart(2, "0");
+    const s = String(t.getSeconds()).padStart(2, "0");
+    fname = `${h}-${m}-${s}`;
+    endpoint = "/raw-store/statistics";
+  } else {
+    subdir = "unknown";
+    fname = "unknown";
+    endpoint = "unknown";
+  }
+  const dumpDir = path3.join(dir, type, subdir);
+  const filename = `${fname}.json`;
+  const filePath = path3.join(dumpDir, filename);
   const payload = {
     _dumpMeta: {
       type,
       dumpedAt: new Date().toISOString(),
-      endpoint: type === "conversation" ? "/raw-store/task-conversation" : type === "summary" ? "/raw-store/task-summary" : "/raw-store/commit"
+      endpoint
     },
     ...body
   };
+  await fs3.mkdir(dumpDir, { recursive: true });
   await fs3.writeFile(filePath, JSON.stringify(payload, null, 2) + `
 `, "utf-8");
 }
@@ -698,11 +798,11 @@ function clearQueue() {
 function getQueue() {
   return [...queue];
 }
-async function acquireLock() {
+async function acquireQueueLock() {
   try {
     try {
-      const stat = await fs4.readFile(QUEUE_LOCK_FILE, "utf-8");
-      const pid = parseInt(stat, 10);
+      const stat2 = await fs4.readFile(QUEUE_LOCK_FILE, "utf-8");
+      const pid = parseInt(stat2, 10);
       if (!isNaN(pid) && pid !== process.pid) {
         try {
           process.kill(pid, 0);
@@ -716,110 +816,84 @@ async function acquireLock() {
     return false;
   }
 }
-async function releaseLock() {
+async function releaseQueueLock() {
   try {
     await fs4.writeFile(QUEUE_LOCK_FILE, "", "utf-8");
   } catch {}
 }
 
-// src/services/rawDump/statistics.ts
-function getTodayKey() {
-  const now = new Date;
-  const year = now.getFullYear();
-  const month = String(now.getMonth() + 1).padStart(2, "0");
-  const day = String(now.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-var globalStats = {
-  dateKey: getTodayKey(),
-  sessionCount: 0,
-  conversationCount: 0,
-  upstreamTokens: 0,
-  downstreamTokens: 0,
-  startTime: 0,
-  endTime: 0
-};
-function resetGlobalStats() {
-  globalStats = {
-    dateKey: getTodayKey(),
-    sessionCount: 0,
-    conversationCount: 0,
-    upstreamTokens: 0,
-    downstreamTokens: 0,
-    startTime: 0,
-    endTime: 0
-  };
-}
-function shallowEqual(obj1, obj2) {
-  const keys1 = Object.keys(obj1);
-  const keys2 = Object.keys(obj2);
-  if (keys1.length !== keys2.length)
-    return false;
-  return keys1.every((key) => obj1[key] === obj2[key]);
-}
-function updateStatistics(dateKey) {
-  const dateValue = state_statistics.statistics[dateKey];
-  if (!dateValue) {
-    state_statistics.statistics[dateKey] = {
-      lastUploadAt: "",
-      currentUploadAt: "",
-      daily: Object.assign({}, globalStats)
-    };
-  } else {
-    if (shallowEqual(globalStats, dateValue)) {
-      return;
+// src/services/rawDump/history.ts
+import { promises as fs5 } from "fs";
+import os5 from "os";
+import path5 from "path";
+var HISTORY_FILE = path5.join(os5.homedir(), ".claude", "history.jsonl");
+var cache = null;
+async function loadHistory() {
+  const items = [];
+  let fileStat = null;
+  try {
+    fileStat = await fs5.stat(HISTORY_FILE);
+  } catch {
+    cache = null;
+    return [];
+  }
+  try {
+    const content = await fs5.readFile(HISTORY_FILE, "utf-8");
+    const lines = content.split(`
+`);
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      try {
+        const item = JSON.parse(line);
+        items.push(item);
+      } catch {}
     }
-    Object.assign(state_statistics.statistics[dateKey].daily, globalStats);
-    state_statistics.statistics[dateKey].currentUploadAt = "";
+  } catch {
+    return cache?.items ?? [];
   }
+  cache = {
+    mtime: fileStat.mtimeMs,
+    size: fileStat.size,
+    items
+  };
+  return cache.items;
 }
-function checkAndResetForNewDay() {
-  const todayKey = getTodayKey();
-  if (globalStats.dateKey === todayKey) {
-    return;
+async function autoLoadHistory() {
+  let fileStat = null;
+  try {
+    fileStat = await fs5.stat(HISTORY_FILE);
+  } catch {
+    if (cache) {
+      return null;
+    }
+    return [];
   }
-  updateStatistics(globalStats.dateKey);
-  const saved = state_statistics.statistics[todayKey];
-  if (!saved) {
-    resetGlobalStats();
-  } else {
-    Object.assign(globalStats, saved.daily);
+  if (cache && cache.mtime === fileStat.mtimeMs && cache.size === fileStat.size) {
+    return cache.items;
   }
+  return await loadHistory();
 }
-function incrementSession(timestamp) {
-  checkAndResetForNewDay();
-  globalStats.sessionCount++;
-  updateTimeRange(timestamp);
-}
-function incrementConversation(timestamp) {
-  checkAndResetForNewDay();
-  globalStats.conversationCount++;
-  updateTimeRange(timestamp);
-}
-function addTokens(upstream, downstream, timestamp) {
-  checkAndResetForNewDay();
-  globalStats.upstreamTokens += upstream;
-  globalStats.downstreamTokens += downstream;
-  updateTimeRange(timestamp);
-}
-function updateTimeRange(timestamp) {
-  if (globalStats.startTime === 0 || timestamp < globalStats.startTime) {
-    globalStats.startTime = timestamp;
-  }
-  if (globalStats.endTime === 0 || timestamp > globalStats.endTime) {
-    globalStats.endTime = timestamp;
+async function getProjectDirs() {
+  if (cache) {
+    let fileStat = null;
+    try {
+      fileStat = await fs5.stat(HISTORY_FILE);
+    } catch {
+      return [...new Set(cache.items.map((item) => item.project))];
+    }
+    if (fileStat.mtimeMs === cache.mtime && fileStat.size === cache.size) {
+      return [...new Set(cache.items.map((item) => item.project))];
+    }
   }
-}
-function updateStatisticsForUpload() {
-  checkAndResetForNewDay();
-  const todayKey = getTodayKey();
-  updateStatistics(todayKey);
+  const items = await loadHistory();
+  return [...new Set(items.map((item) => item.project))];
 }
 
 // src/services/rawDump/session.ts
-import { promises as fs5 } from "fs";
-import os5 from "os";
-import path5 from "path";
+import { promises as fs6 } from "fs";
+import os6 from "os";
+import path6 from "path";
 
 // src/services/rawDump/parse.ts
 function buildFlows(events) {
@@ -1179,22 +1253,22 @@ function parseSession(cacheConversations, events) {
 }
 
 // src/services/rawDump/session.ts
-var log = createLogger("raw-dump-session");
+var log2 = createLogger("session");
 function getClaudeConfigHomeDir() {
-  return process.env.CLAUDE_CONFIG_HOME || path5.join(os5.homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_HOME || path6.join(os6.homedir(), ".claude");
 }
-function normalizeProjectPath(dir) {
+function normalizeProjectPath2(dir) {
   return dir.replace(/:/g, "-").replace(/[/\\]/g, "-");
 }
 function getSessionDirectory(directory) {
   const claudeHome = getClaudeConfigHomeDir();
-  const projectPath = normalizeProjectPath(directory);
+  const projectPath = normalizeProjectPath2(directory);
   const candidates = [
-    path5.join(claudeHome, "projects", projectPath),
-    path5.join(claudeHome, "transcripts"),
-    path5.join(claudeHome, "sessions"),
-    path5.join(directory, ".claude", "sessions"),
-    path5.join(directory, ".claude"),
+    path6.join(claudeHome, "projects", projectPath),
+    path6.join(claudeHome, "transcripts"),
+    path6.join(claudeHome, "sessions"),
+    path6.join(directory, ".claude", "sessions"),
+    path6.join(directory, ".claude"),
     directory,
     process.env.CSC_SESSION_DIR || ""
   ];
@@ -1202,7 +1276,7 @@ function getSessionDirectory(directory) {
 }
 async function loadSessionMessages(sessionFile) {
   try {
-    const text = await fs5.readFile(sessionFile, "utf-8");
+    const text = await fs6.readFile(sessionFile, "utf-8");
     const messages = text.split(`
 `).filter(Boolean).map((line) => {
       try {
@@ -1211,7 +1285,7 @@ async function loadSessionMessages(sessionFile) {
         return null;
       }
     }).filter((m) => m !== null);
-    log.debug("loaded messages from file", {
+    log2.debug("loaded messages from file", {
       sessionFile,
       count: messages.length
     });
@@ -1234,10 +1308,10 @@ async function getParsedSession(taskDir, sessionId) {
   const sessionDir = getSessionDirectory(taskDir);
   const cacheKey = `${sessionDir}:${sessionId}`;
   const cached = sessionMessagesCache.get(cacheKey);
-  const sessionFile = path5.join(sessionDir, `${sessionId}.jsonl`);
+  const sessionFile = path6.join(sessionDir, `${sessionId}.jsonl`);
   let stats;
   try {
-    stats = await fs5.stat(sessionFile);
+    stats = await fs6.stat(sessionFile);
   } catch {
     return {
       sessionJsonlFileName: sessionFile,
@@ -1250,7 +1324,7 @@ async function getParsedSession(taskDir, sessionId) {
   }
   const needsReanalysis = !cached || cached.fileTimestamp !== stats.mtimeMs || cached.fileSize !== stats.size || !cached.parsedSession;
   if (!needsReanalysis && cached) {
-    log.debug("using cached parsed session", { sessionId });
+    log2.debug("using cached parsed session", { sessionId });
     return cached;
   }
   cleanupOldSessions();
@@ -1258,9 +1332,9 @@ async function getParsedSession(taskDir, sessionId) {
   const messages = cached?.messages ?? await loadSessionMessages(sessionFile);
   const elapsed = Date.now() - start;
   if (elapsed > 100) {
-    log.info("loadSessionMessages slow", { sessionId, elapsedMs: elapsed });
+    log2.info("loadSessionMessages slow", { sessionId, elapsedMs: elapsed });
   }
-  log.debug("reparsing session", { sessionId });
+  log2.debug("reparsing session", { sessionId });
   const cachedConvs = cached?.parsedSession?.conversations ?? [];
   const parsedSession = parseSession(cachedConvs, messages);
   sessionMessagesCache.set(cacheKey, {
@@ -1275,76 +1349,132 @@ async function getParsedSession(taskDir, sessionId) {
   return cacheEntry;
 }
 
-// src/services/rawDump/history.ts
-import { promises as fs6 } from "fs";
-import os6 from "os";
-import path6 from "path";
-var HISTORY_FILE = path6.join(os6.homedir(), ".claude", "history.jsonl");
-var cache = null;
-async function loadHistory() {
-  const items = [];
-  let fileStat = null;
-  try {
-    fileStat = await fs6.stat(HISTORY_FILE);
-  } catch {
-    cache = null;
-    return [];
-  }
-  try {
-    const content = await fs6.readFile(HISTORY_FILE, "utf-8");
-    const lines = content.split(`
-`);
-    for (const line of lines) {
-      if (!line.trim())
-        continue;
-      try {
-        const item = JSON.parse(line);
-        items.push(item);
-      } catch {}
+// src/services/rawDump/statistics.ts
+var log3 = createLogger("worker");
+async function updateStatisticsForUpload() {
+  const dailyStats = await statHistorySessions();
+  for (const [_dateKey, stats] of dailyStats) {
+    const existing = state_statistics.statistics[stats.dateKey];
+    if (existing) {
+      const isSame = existing.daily.sessionCount === stats.sessionCount && existing.daily.conversationCount === stats.conversationCount && existing.daily.upstreamTokens === stats.upstreamTokens && existing.daily.downstreamTokens === stats.downstreamTokens && existing.daily.startTime === stats.startTime && existing.daily.endTime === stats.endTime;
+      if (!isSame) {
+        Object.assign(state_statistics.statistics[stats.dateKey].daily, stats);
+        state_statistics.statistics[stats.dateKey].currentUploadAt = "";
+      }
+    } else {
+      const startTime = new Date(_dateKey);
+      if (state_statistics.clean_time && startTime < new Date(state_statistics.clean_time)) {
+        log3.info("statistics skipped: too old", {
+          startTime: startTime.toISOString(),
+          clean_time: state_statistics.clean_time
+        });
+      } else {
+        state_statistics.statistics[stats.dateKey] = {
+          lastUploadAt: "",
+          currentUploadAt: "",
+          daily: { ...stats }
+        };
+      }
     }
-  } catch {
-    return cache?.items ?? [];
   }
-  cache = {
-    mtime: fileStat.mtimeMs,
-    size: fileStat.size,
-    items,
-    lastLoadTime: Date.now(),
-    lastProcessedIndex: -1
-  };
-  return cache.items;
+  await saveStatistics();
 }
-async function autoLoadHistory() {
-  let fileStat = null;
-  try {
-    fileStat = await fs6.stat(HISTORY_FILE);
-  } catch {
-    if (cache) {
-      return null;
+async function statHistorySessions() {
+  const items = await autoLoadHistory();
+  const dailyStats = new Map;
+  const seen = new Set;
+  const uniqueItems = (items ?? []).filter((item) => {
+    if (seen.has(item.sessionId))
+      return false;
+    seen.add(item.sessionId);
+    return true;
+  });
+  const sessionDateMap = new Map;
+  for (const item of uniqueItems) {
+    const cacheEntry = await getParsedSession(item.project, item.sessionId);
+    const messages = cacheEntry.messages;
+    if (!messages || messages.length === 0)
+      continue;
+    let sessionTimestamp = 0;
+    let sessionUpstreamTokens = 0;
+    let sessionDownstreamTokens = 0;
+    for (const msg of messages) {
+      if (msg.timestamp) {
+        const ts = new Date(msg.timestamp).getTime();
+        if (sessionTimestamp === 0 || ts < sessionTimestamp) {
+          sessionTimestamp = ts;
+        }
+      }
+      const usage = msg.message?.usage;
+      if (usage) {
+        sessionUpstreamTokens += (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+        sessionDownstreamTokens += usage.output_tokens ?? 0;
+      }
+    }
+    const sessionDateKey = sessionTimestamp ? new Date(sessionTimestamp).toISOString().slice(0, 10) : new Date().toISOString().slice(0, 10);
+    sessionDateMap.set(item.sessionId, sessionDateKey);
+    let conversationCount = 0;
+    let upstreamTokens = 0;
+    let downstreamTokens = 0;
+    let startTime = 0;
+    let endTime = 0;
+    for (const msg of messages) {
+      if (msg.type === "user") {
+        conversationCount++;
+      }
+      const usage = msg.message?.usage;
+      if (usage) {
+        upstreamTokens += (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+        downstreamTokens += usage.output_tokens ?? 0;
+      }
+      if (msg.timestamp) {
+        const ts = new Date(msg.timestamp).getTime();
+        if (startTime === 0 || ts < startTime) {
+          startTime = ts;
+        }
+        if (endTime === 0 || ts > endTime) {
+          endTime = ts;
+        }
+      }
+    }
+    const dateKey = sessionDateKey;
+    if (!dailyStats.has(dateKey)) {
+      dailyStats.set(dateKey, {
+        dateKey,
+        sessionCount: 0,
+        conversationCount: 0,
+        upstreamTokens: 0,
+        downstreamTokens: 0,
+        startTime: 0,
+        endTime: 0
+      });
+    }
+    const stats = dailyStats.get(dateKey);
+    stats.conversationCount += conversationCount;
+    stats.upstreamTokens += upstreamTokens;
+    stats.downstreamTokens += downstreamTokens;
+    if (startTime > 0) {
+      if (stats.startTime === 0 || startTime < stats.startTime) {
+        stats.startTime = startTime;
+      }
+    }
+    if (endTime > 0) {
+      if (stats.endTime === 0 || endTime > stats.endTime) {
+        stats.endTime = endTime;
+      }
     }
-    return [];
-  }
-  if (cache && cache.mtime === fileStat.mtimeMs && cache.size === fileStat.size) {
-    return null;
-  }
-  return await loadHistory();
-}
-async function fetchIncompleteItems() {
-  await autoLoadHistory();
-  if (!cache || cache.items.length === 0) {
-    return { items: [], startNo: -1 };
   }
-  const startIndex = cache.lastProcessedIndex === -1 ? 0 : cache.lastProcessedIndex + 1;
-  const startNo = startIndex;
-  const incompleteItems = cache.items.slice(startIndex);
-  if (incompleteItems.length > 0) {
-    cache.lastProcessedIndex = cache.items.length - 1;
+  for (const [_sessionId, dateKey] of sessionDateMap) {
+    const stats = dailyStats.get(dateKey);
+    if (stats) {
+      stats.sessionCount++;
+    }
   }
-  return { items: incompleteItems, startNo };
+  return dailyStats;
 }
 
 // src/services/rawDump/worker.ts
-var log2 = createLogger("raw-dump");
+var log4 = createLogger("worker");
 var REQUEST_TIMEOUT_MS = 30000;
 var repoInfoCache = new Map;
 var REPO_CACHE_TTL_MS = 60000;
@@ -1357,40 +1487,14 @@ async function getCachedRepoInfo(directory) {
   repoInfoCache.set(directory, { repoInfo, ts: Date.now() });
   return repoInfo;
 }
-function statisticsMessages(messages) {
-  let upstreamTokens = 0;
-  let downstreamTokens = 0;
-  let startTime = 0;
-  let endTime = 0;
-  for (const msg of messages) {
-    const usage = msg.message?.usage;
-    if (usage) {
-      upstreamTokens += (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
-      downstreamTokens += usage.output_tokens ?? 0;
-    }
-    const ts = msg.timestamp;
-    if (ts) {
-      const numTs = typeof ts === "number" ? ts : new Date(ts).getTime();
-      if (startTime === 0 || numTs < startTime)
-        startTime = numTs;
-      if (endTime === 0 || numTs > endTime)
-        endTime = numTs;
-    }
-  }
-  const latestTs = endTime || Date.now();
-  incrementConversation(latestTs);
-  addTokens(upstreamTokens, downstreamTokens, latestTs);
-  incrementSession(startTime || Date.now());
-}
 async function processTask(task) {
-  log2.info("processing task:", { task });
+  log4.info("processing task:", { task });
   const authData = await authWithFallback();
   const repoInfo = await getCachedRepoInfo(task.directory);
   const cacheEntry = await getParsedSession(task.directory, task.sessionId);
   const parsedSession = cacheEntry.parsedSession;
-  statisticsMessages(cacheEntry.messages);
   if (parsedSession.conversations.length === 0) {
-    log2.warn("no conversations found", { task });
+    log4.warn("no conversations found", { task });
   }
   await uploadSummary({ sessionId: task.sessionId, directory: task.directory, parsedSession }, authData);
   for (const conv of parsedSession.conversations) {
@@ -1400,7 +1504,7 @@ async function processTask(task) {
       conversation: conv
     }, authData, { repoInfo });
   }
-  log2.info("task completed", {
+  log4.info("task completed", {
     sessionId: task.sessionId,
     conversationCount: parsedSession.conversations.length
   });
@@ -1437,21 +1541,26 @@ function getRawDumpUrl(baseUrl, endpoint, isAnonymous = false) {
 async function uploadReport(authData, endpoint, body) {
   const mode = getRawDumpMode();
   if (mode === RAW_DUMP_MODE.DISABLED) {
-    log2.debug(`dump disabled, skipping ${endpoint}`);
+    log4.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" : "unknown";
   if (type === "unknown") {
-    log2.warn("unknown endpoint, skipping local dump", { endpoint });
+    log4.warn("unknown endpoint, skipping local dump", { endpoint });
   } else if (mode === RAW_DUMP_MODE.LOCAL || mode === RAW_DUMP_MODE.BOTH) {
     await writeLocalDump(type, body);
   }
+  if (mode === RAW_DUMP_MODE.LOCAL)
+    return;
+  await writeRemoteDump(endpoint, authData, body);
+}
+async function writeRemoteDump(endpoint, authData, body) {
   const isAnonymous = authData.isAnonymous ?? false;
   const url = getRawDumpUrl(authData.baseUrl, endpoint, isAnonymous);
-  log2.debug(`POST ${endpoint}`, { url, authData, isAnonymous });
+  log4.debug(`POST ${endpoint}`, { url, authData, isAnonymous });
   try {
     await postJson(url, body, authData.headers);
-    log2.debug(`POST ${endpoint} ok`);
+    log4.debug(`POST ${endpoint} ok`);
     return;
   } catch (err) {
     throw err instanceof UploadError ? err : new Error(`${endpoint} failed after 3 attempts`);
@@ -1492,18 +1601,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) {
-        log2.warn(`retryable error ${res.status}, will retry`, { url, attempt, status: res.status });
+        log4.warn(`retryable error ${res.status}, will retry`, { url, attempt, status: res.status });
         continue;
       }
       if (res.status === 401 || res.status === 502 || res.status === 503) {
-        log2.warn(`retryable status ${res.status}, will retry`, { url, attempt });
+        log4.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";
-      log2.warn(`${isAbort ? "timeout" : "network error"}, will retry`, {
+      log4.warn(`${isAbort ? "timeout" : "network error"}, will retry`, {
         url,
         attempt,
         timeoutMs: REQUEST_TIMEOUT_MS,
@@ -1513,7 +1622,7 @@ async function postJson(url, body, headers, maxAttempts = 3) {
       clearTimeout(timer);
     }
   }
-  log2.error("postJson failed", {
+  log4.error("postJson failed", {
     url,
     headers: headersObj,
     error: lastError?.message
@@ -1541,16 +1650,16 @@ function detectOs() {
   return map[process.platform] ?? process.platform;
 }
 async function auth() {
-  log2.debug("auth start");
+  log4.debug("auth start");
   let creds = await loadCoStrictCredentials();
   if (!creds?.access_token)
     throw new Error("Not authenticated");
-  log2.debug("credentials loaded", {
+  log4.debug("credentials loaded", {
     hasRefreshToken: !!creds.refresh_token,
     baseUrl: creds.base_url
   });
   if (creds.refresh_token && !isCoStrictTokenValid(creds)) {
-    log2.debug("token expired, refreshing...");
+    log4.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,
@@ -1569,7 +1678,7 @@ async function auth() {
       access_token: next.access_token,
       refresh_token: next.refresh_token
     };
-    log2.debug("token refreshed");
+    log4.debug("token refreshed");
   }
   const headers = new Headers;
   headers.set("Authorization", `Bearer ${creds.access_token}`);
@@ -1598,7 +1707,7 @@ async function auth() {
   }
   const user = parseUser(accessPayload, refreshPayload);
   const baseUrl = resolveRawDumpBaseUrl(creds.base_url);
-  log2.debug("auth success", {
+  log4.debug("auth success", {
     baseUrl,
     user_id: user.user_id,
     clientId,
@@ -1613,18 +1722,76 @@ async function auth() {
     isAnonymous: false
   };
 }
+async function authWithFallback() {
+  try {
+    return await auth();
+  } catch (err) {
+    log4.info("auth failed, falling back to anonymous interface", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    let version = "unknown";
+    try {
+      const pkgPath = path7.resolve(fileURLToPath(import.meta.url), "../../package.json");
+      log4.info("pkgPath:", { meta_url: import.meta.url, pkgPath });
+      const pkg = JSON.parse(await fs7.readFile(pkgPath, "utf-8"));
+      version = pkg.version ?? "unknown";
+    } catch {}
+    let deviceId = process.env.CSC_DEVICE_ID;
+    if (!deviceId) {
+      const deviceIdFile = path7.join(getLocalDumpDir(), "device-id");
+      try {
+        deviceId = (await fs7.readFile(deviceIdFile, "utf-8")).trim();
+      } catch {}
+      if (!deviceId) {
+        deviceId = generateMachineId();
+        try {
+          await fs7.writeFile(deviceIdFile, deviceId, "utf-8");
+        } catch {}
+      }
+      process.env.CSC_DEVICE_ID = deviceId;
+      log4.debug("resolved CSC_DEVICE_ID", { deviceId });
+    }
+    const headers = new Headers;
+    headers.set("Content-Type", "application/json");
+    headers.set("Authorization", `${createHash2("md5").update(deviceId).digest("hex")}`);
+    headers.set("zgsm-client-id", deviceId);
+    headers.set("zgsm-client-ide", "cli");
+    headers.set("X-Costrict-Version", `csc-${version}`);
+    headers.set("User-Agent", `csc/${version}`);
+    return {
+      baseUrl: resolveRawDumpBaseUrl(),
+      headers,
+      user: {
+        user_id: "anonymous",
+        user_name: "anonymous"
+      },
+      clientId: deviceId,
+      version,
+      isAnonymous: true
+    };
+  }
+}
 async function uploadConversation(payload, authData, options) {
   const conv = payload.conversation;
   const requestID = conv.id;
   const key = `${payload.sessionId}:${requestID}`;
   if (state_conv.conversation[key]) {
-    log2.info("conversation skipped: already uploaded", {
+    log4.info("conversation skipped: already uploaded", {
       task_id: payload.sessionId,
       request_id: requestID,
       last_reported: state_conv.conversation[key]
     });
     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", {
+      task_id: payload.sessionId,
+      request_id: requestID,
+      clean_time: state_conv.clean_time,
+      start_time: payload.conversation.startTime.toISOString()
+    });
+    return false;
+  }
   const rawDiff = conv.diffs.map((d) => d.content).join(`
 `);
   const diffLines = rawDiff ? countDiffLines(rawDiff) : 0;
@@ -1656,7 +1823,7 @@ async function uploadConversation(payload, authData, options) {
     repo_branch: repoInfo.repo_branch,
     work_dir: payload.directory
   };
-  log2.debug("conversation uploading", {
+  log4.debug("conversation uploading", {
     task_id: payload.sessionId,
     request_id: requestID
   });
@@ -1667,7 +1834,7 @@ async function uploadConversation(payload, authData, options) {
   if (wasIncomplete)
     state_conv.incomplete--;
   await saveConversation();
-  log2.info("conversation uploaded", {
+  log4.info("conversation uploaded", {
     task_id: payload.sessionId,
     request_id: requestID,
     upstream_tokens: body.upstream_tokens,
@@ -1677,18 +1844,25 @@ async function uploadConversation(payload, authData, options) {
 }
 async function uploadSummary(payload, authData) {
   const parsed = payload.parsedSession;
-  log2.debug("uploadSummary start", {
+  log4.debug("uploadSummary start", {
     sessionId: payload.sessionId,
     conversationCount: parsed.conversations.length
   });
   if (state_summary.summary[payload.sessionId]) {
-    log2.info("summary skipped: already uploaded", {
+    log4.info("summary skipped: already uploaded", {
       task_id: payload.sessionId
     });
     return;
   }
   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", {
+      startTime: startTime.toISOString(),
+      clean_time: state_summary.clean_time
+    });
+    return;
+  }
   const body = {
     task_id: payload.sessionId,
     start_time: formatIso(startTime),
@@ -1707,31 +1881,30 @@ async function uploadSummary(payload, authData) {
   if (wasIncomplete)
     state_summary.incomplete--;
   await saveSummary();
-  log2.info("summary uploaded", { task_id: payload.sessionId });
+  log4.info("summary uploaded", { task_id: payload.sessionId });
 }
-async function uploadCommits(payload, authData, options) {
-  log2.debug("uploadCommits start", { directory: payload.directory });
-  const repoInfo = options?.repoInfo ?? await getRepoInfo(payload.directory);
+async function uploadCommits(directory, authData, options) {
+  const repoInfo = options?.repoInfo ?? await getRepoInfo(directory);
   if (!repoInfo.repo_addr || !repoInfo.repo_branch) {
-    log2.info("commits skipped: missing repo info", {
-      work_dir: payload.directory,
+    log4.info("commits skipped: missing repo info", {
+      work_dir: directory,
       repo_addr: repoInfo.repo_addr,
       repo_branch: repoInfo.repo_branch
     });
     return 0;
   }
-  const stateKey = `${repoInfo.repo_addr}#${repoInfo.repo_branch}#${payload.directory}`;
+  const stateKey = `${repoInfo.repo_addr}#${repoInfo.repo_branch}#${directory}`;
   const lastCommit = state_commit.commits[stateKey];
-  log2.debug("commits state", { stateKey, lastCommit: lastCommit || "" });
-  const logText = await getCommitLog(payload.directory, lastCommit);
+  log4.debug("commits state", { stateKey, lastCommit: lastCommit || "" });
+  const logText = await getCommitLog(directory, lastCommit);
   const allCommits = parseCommitLog(logText);
   const commits = allCommits.slice(0, 50);
-  log2.debug("parsed commits", {
+  log4.debug("parsed commits", {
     total: allCommits.length,
     sending: commits.length
   });
   if (!commits.length) {
-    log2.info("commits skipped: no new commits", { work_dir: payload.directory });
+    log4.info("commits skipped: no new commits", { work_dir: directory });
     return 0;
   }
   const originalLastCommit = state_commit.commits[stateKey] || "";
@@ -1742,7 +1915,7 @@ async function uploadCommits(payload, authData, options) {
       if (i > 0 && i % 10 === 0) {
         await new Promise((r) => setTimeout(r, 500));
       }
-      const diff = await getCommitDiff(payload.directory, commit.commit_id);
+      const diff = await getCommitDiff(directory, commit.commit_id);
       const body = {
         commit_id: commit.commit_id,
         commit_time: commit.commit_time,
@@ -1754,7 +1927,7 @@ async function uploadCommits(payload, authData, options) {
         client_id: authData.clientId,
         client_version: authData.version,
         client_ide: "cli",
-        work_dir: payload.directory,
+        work_dir: directory,
         diff_lines: countDiffLines(diff),
         diff,
         files: extractFilesFromDiff(diff),
@@ -1766,7 +1939,7 @@ async function uploadCommits(payload, authData, options) {
       uploadedCount++;
       state_commit.commits[stateKey] = commit.commit_id;
       await saveCommits();
-      log2.info("commit uploaded", {
+      log4.info("commit uploaded", {
         commit_id: commit.commit_id,
         progress: `${i + 1}/${commits.length}`
       });
@@ -1774,8 +1947,8 @@ async function uploadCommits(payload, authData, options) {
   } catch (err) {
     state_commit.commits[stateKey] = originalLastCommit;
     await saveCommits();
-    log2.error("commit batch failed, rolled back", {
-      work_dir: payload.directory,
+    log4.error("commit batch failed, rolled back", {
+      work_dir: directory,
       uploadedCount,
       error: err instanceof Error ? err.message : String(err)
     });
@@ -1783,14 +1956,14 @@ async function uploadCommits(payload, authData, options) {
   }
   return commits.length;
 }
-async function uploadStatistics(payload, authData) {
+async function uploadStatistics(authData) {
   updateStatisticsForUpload();
   for (const [k, r] of Object.entries(state_statistics.statistics)) {
     if (r.currentUploadAt)
       continue;
     const daily = r.daily;
     const body = {
-      task_id: payload.sessionId,
+      date: k,
       start_time: formatIso(new Date(daily.startTime)),
       end_time: formatIso(new Date(daily.endTime)),
       ...authData.user,
@@ -1807,7 +1980,7 @@ async function uploadStatistics(payload, authData) {
     state_statistics.statistics[k].currentUploadAt = timestamp;
     state_statistics.incomplete--;
     await saveStatistics();
-    log2.info("statistics uploaded", {
+    log4.info("statistics uploaded", {
       k,
       session_count: daily.sessionCount,
       conversation_count: daily.conversationCount,
@@ -1829,7 +2002,7 @@ async function processIncompleteTasks() {
       await saveTasks();
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
-      log2.error("task failed", {
+      log4.error("task failed", {
         error: errorMsg,
         task: record
       });
@@ -1850,7 +2023,7 @@ async function processIncompleteTasks() {
         state_task.tasks[key].uploadedAt = "DEAD_LETTER";
         state_task.incomplete--;
         await saveTasks();
-        log2.error("task moved to dead letter", {
+        log4.error("task moved to dead letter", {
           key,
           attemptCount: state_task.tasks[key].attemptCount
         });
@@ -1858,269 +2031,194 @@ async function processIncompleteTasks() {
     }
   }
 }
-async function runHistoryWorker() {
+async function runHistorySessionWorker() {
   try {
-    log2.info("history start");
-    const { items: newItems, startNo } = await fetchIncompleteItems();
-    log2.info("history loaded: ", { startNo, length: newItems.length });
-    addHistoryTasks(startNo, newItems);
+    log4.info("history session start");
+    const items = await autoLoadHistory();
+    log4.info("history session loaded: ", { length: items ? items.length : 0 });
+    addHistoryTasks(items ?? []);
     await saveTasks();
   } catch (err) {
-    log2.error("history failed", {
+    log4.error("history failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
-  log2.info(`tracking ${state_task.total} tasks total, ${state_task.incomplete} incomplete`);
+  log4.info(`tracking ${state_task.total} tasks total, ${state_task.incomplete} incomplete`);
   try {
     await processIncompleteTasks();
-    log2.info("history completed");
+    log4.info("history completed");
   } catch (err) {
-    log2.error("history process failed, queue retained", {
+    log4.error("history process failed, queue retained", {
       error: err instanceof Error ? err.message : String(err)
     });
     throw err;
   }
 }
 async function runRawDumpWorker() {
+  log4.info("WORKER start");
   try {
-    log2.info("WORKER start");
     await loadAllState();
+    await runHistorySessionWorker();
+    await runCommitTimer();
+    await runStatisticsTimer();
   } catch (err) {
-    log2.error("WORKER failed", {
+    log4.error("WORKER failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
-  runHistoryWorker();
+  log4.info("WORKER end");
 }
-async function authWithFallback() {
-  try {
-    return await auth();
-  } catch (err) {
-    log2.info("auth failed, falling back to anonymous interface", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-    let version = "unknown";
-    try {
-      const pkgPath = path7.resolve(fileURLToPath(import.meta.url), "../../package.json");
-      log2.info("pkgPath:", { meta_url: import.meta.url, pkgPath });
-      const pkg = JSON.parse(await fs7.readFile(pkgPath, "utf-8"));
-      version = pkg.version ?? "unknown";
-    } catch {}
-    let deviceId = process.env.CSC_DEVICE_ID;
-    if (!deviceId) {
-      const deviceIdFile = path7.join(getLocalDumpDir(), "device-id");
-      try {
-        deviceId = (await fs7.readFile(deviceIdFile, "utf-8")).trim();
-      } catch {}
-      if (!deviceId) {
-        deviceId = generateMachineId();
-        try {
-          await fs7.writeFile(deviceIdFile, deviceId, "utf-8");
-        } catch {}
-      }
-      process.env.CSC_DEVICE_ID = deviceId;
-      log2.debug("resolved CSC_DEVICE_ID", { deviceId });
-    }
-    const headers = new Headers;
-    headers.set("Content-Type", "application/json");
-    headers.set("Authorization", `${createHash2("md5").update(deviceId).digest("hex")}`);
-    headers.set("zgsm-client-id", deviceId);
-    headers.set("zgsm-client-ide", "cli");
-    headers.set("X-Costrict-Version", `csc-${version}`);
-    headers.set("User-Agent", `csc/${version}`);
-    return {
-      baseUrl: resolveRawDumpBaseUrl(),
-      headers,
-      user: {
-        user_id: "anonymous",
-        user_name: "anonymous"
-      },
-      clientId: deviceId,
-      version,
-      isAnonymous: true
-    };
-  }
-}
-var scriptPath = process.argv[1] || "";
-if (scriptPath.endsWith("worker.ts") || scriptPath.endsWith("worker.js")) {
-  runRawDumpWorker();
-}
-
-// src/services/rawDump/timerWorker.ts
-import { promises as fs8 } from "fs";
-import os8 from "os";
-import path8 from "path";
-var log3 = createLogger("raw-dump-timer");
-var TIMER_LOCK_FILE = path8.join(os8.homedir(), ".claude", "raw-dump", "csc-timer.lock");
-var HISTORY_FILE2 = path8.join(os8.homedir(), ".claude", "history.jsonl");
 var COMMIT_INTERVAL_MS = 5 * 60 * 1000;
 var STATS_INTERVAL_MS = 60 * 60 * 1000;
 var QUEUE_INTERVAL_MS = 120000;
-var isRunning = false;
-var lastCommitRun = 0;
 var lastStatsRun = 0;
 var lastQueueRun = 0;
-var projectDirsCache = null;
-async function acquireTimerLock() {
-  try {
-    const stat = await fs8.readFile(TIMER_LOCK_FILE, "utf-8").catch(() => "");
-    const pid = parseInt(stat.trim(), 10);
-    if (!isNaN(pid) && pid !== process.pid) {
-      try {
-        process.kill(pid, 0);
-        return false;
-      } catch {}
-    }
-    await fs8.writeFile(TIMER_LOCK_FILE, String(process.pid), "utf-8");
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function releaseTimerLock() {
-  try {
-    await fs8.writeFile(TIMER_LOCK_FILE, "", "utf-8");
-  } catch {}
-}
-async function getProjectDirs() {
-  try {
-    const stat = await fs8.stat(HISTORY_FILE2);
-    if (projectDirsCache && projectDirsCache.mtime === stat.mtimeMs && projectDirsCache.size === stat.size) {
-      return projectDirsCache.dirs;
-    }
-  } catch {
-    if (projectDirsCache) {
-      return projectDirsCache.dirs;
-    }
-    return [];
-  }
-  const projects = new Set;
-  try {
-    const content = await fs8.readFile(HISTORY_FILE2, "utf-8");
-    const lines = content.split(`
-`);
-    for (const line of lines) {
-      if (!line.trim())
-        continue;
-      try {
-        const record = JSON.parse(line);
-        if (record.project) {
-          projects.add(record.project);
-        }
-      } catch {}
-    }
-  } catch {
-    return projectDirsCache ? projectDirsCache.dirs : [];
-  }
-  const dirs = [...projects];
-  try {
-    const stat = await fs8.stat(HISTORY_FILE2);
-    projectDirsCache = { mtime: stat.mtimeMs, size: stat.size, dirs };
-  } catch {}
-  return dirs;
+var lastCommitRun = 0;
+function getTimerIntervals() {
+  return {
+    commitIntervalMs: COMMIT_INTERVAL_MS,
+    statsIntervalMs: STATS_INTERVAL_MS,
+    queueIntervalMs: QUEUE_INTERVAL_MS
+  };
 }
 async function runCommitTimer() {
   const now = Date.now();
   if (now - lastCommitRun < COMMIT_INTERVAL_MS)
     return;
-  log3.debug("commit timer firing");
   lastCommitRun = now;
+  log4.debug("commit timer firing");
   const dirs = await getProjectDirs();
-  log3.debug("scanned project dirs", { count: dirs.length });
+  log4.debug("scanned project dirs", { count: dirs.length });
   const authData = await authWithFallback();
   for (const dir of dirs) {
     try {
-      const repoInfo = await getRepoInfo(dir);
+      const repoInfo = await getCachedRepoInfo(dir);
       if (!repoInfo.repo_addr || !repoInfo.repo_branch) {
-        log3.debug("skip dir: missing repo info", { dir });
+        log4.debug("skip dir: missing repo info", { dir });
         continue;
       }
-      await uploadCommits({ directory: dir }, authData, { repoInfo });
+      await uploadCommits(dir, authData, { repoInfo });
     } catch (err) {
-      log3.error("commit timer failed for dir", {
+      log4.error("commit timer failed for dir", {
         dir,
         error: err instanceof Error ? err.message : String(err)
       });
     }
   }
-  log3.debug("commit timer done");
+  log4.debug("commit timer done");
 }
 async function runStatisticsTimer() {
   const now = Date.now();
   if (now - lastStatsRun < STATS_INTERVAL_MS)
     return;
-  log3.debug("statistics timer firing");
   lastStatsRun = now;
+  log4.debug("statistics timer firing");
   try {
     const authData = await authWithFallback();
-    await uploadStatistics({ sessionId: "", directory: "" }, authData);
+    await uploadStatistics(authData);
   } catch (err) {
-    log3.error("statistics timer failed", {
+    log4.error("statistics timer failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
-  log3.debug("statistics timer done");
+  log4.debug("statistics timer done");
 }
 async function runQueueTimer() {
   const now = Date.now();
   if (now - lastQueueRun < QUEUE_INTERVAL_MS)
     return;
   lastQueueRun = now;
-  log3.debug("queue timer firing");
+  log4.debug("queue timer firing");
+  if (!await acquireQueueLock()) {
+    log4.debug("another worker process holds the lock, skip");
+    return;
+  }
   try {
-    if (!await acquireLock()) {
-      log3.debug("another worker process holds the lock, skip");
-      return;
-    }
     const newTasks = getQueue();
     if (newTasks.length === 0) {
       if (state_task.incomplete === 0) {
-        log3.debug("queue empty, no incomplete tasks");
+        log4.debug("queue empty, no incomplete tasks");
         return;
       }
-      log3.debug("queue empty, but has incomplete tasks in state");
+      log4.debug("queue empty, but has incomplete tasks in state");
     }
-    log3.info(`processing ${newTasks.length} new tasks`);
+    log4.info(`processing ${newTasks.length} new tasks`);
     addQueueTasks(newTasks);
     await saveTasks();
     clearQueue();
   } catch (err) {
-    log3.error("runBatch failed", {
+    log4.error("runBatch failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   } finally {
-    await releaseLock();
+    await releaseQueueLock();
   }
-  log3.info(`tracking ${state_task.total} tasks total, ${state_task.incomplete} incomplete`);
+  log4.info(`tracking ${state_task.total} tasks total, ${state_task.incomplete} incomplete`);
   try {
     await processIncompleteTasks();
-    log3.info("queue timer completed");
+    log4.info("queue timer completed");
   } catch (err) {
-    log3.error("queue timer failed, queue retained", {
+    log4.error("queue timer failed, queue retained", {
       error: err instanceof Error ? err.message : String(err)
     });
     throw err;
   }
 }
+var scriptPath = process.argv[1] || "";
+if (scriptPath.endsWith("worker.ts") || scriptPath.endsWith("worker.js")) {
+  (async () => {
+    await runRawDumpWorker();
+  })();
+}
+
+// src/services/rawDump/timerWorker.ts
+import { promises as fs8 } from "fs";
+import os8 from "os";
+import path8 from "path";
+var log5 = createLogger("timer");
+var TIMER_LOCK_FILE = path8.join(os8.homedir(), ".claude", "raw-dump", "csc-timer.lock");
+var isRunning = false;
+async function acquireTimerLock() {
+  try {
+    const stat2 = await fs8.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 fs8.writeFile(TIMER_LOCK_FILE, String(process.pid), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function releaseTimerLock() {
+  try {
+    await fs8.writeFile(TIMER_LOCK_FILE, "", "utf-8");
+  } catch {}
+}
 async function runTimers() {
   if (isRunning)
     return;
   isRunning = true;
+  if (!await acquireTimerLock()) {
+    log5.debug("another timer worker holds the lock, skip");
+    isRunning = false;
+    return;
+  }
   try {
-    if (!await acquireTimerLock()) {
-      log3.debug("another timer worker holds the lock, skip");
-      return;
-    }
     await runQueueTimer();
     await runCommitTimer();
     await runStatisticsTimer();
-    await releaseTimerLock();
   } catch (err) {
-    log3.error("timer worker error", {
+    log5.error("timer worker error", {
       error: err instanceof Error ? err.message : String(err)
     });
   } finally {
     isRunning = false;
+    await releaseTimerLock();
   }
 }
 function scheduleNext() {
@@ -2128,7 +2226,7 @@ function scheduleNext() {
     try {
       await runTimers();
     } catch (err) {
-      log3.error("runTimers threw", {
+      log5.error("runTimers threw", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -2136,16 +2234,12 @@ function scheduleNext() {
   }, 60000);
 }
 function startTimerWorker() {
-  log3.info("timer worker starting", {
-    commitIntervalMs: COMMIT_INTERVAL_MS,
-    statsIntervalMs: STATS_INTERVAL_MS,
-    queueIntervalMs: QUEUE_INTERVAL_MS
-  });
+  log5.info("timer worker starting", getTimerIntervals());
   setImmediate(async () => {
     try {
       await runTimers();
     } catch (err) {
-      log3.error("initial timer run failed", {
+      log5.error("initial timer run failed", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -2158,24 +2252,32 @@ if (scriptPath2.endsWith("timerWorker.ts") || scriptPath2.endsWith("timerWorker.
 }
 
 // src/services/rawDump/batchWorker.ts
-var log4 = createLogger("raw-dump-batch");
+var log6 = createLogger("batch");
 var PARENT_PID = process.ppid;
 var IS_WORKER_PROCESS = process.argv[1]?.includes("batchWorker") || false;
 function startBatchWorker() {
-  log4.info("batch worker started");
+  log6.info("batch worker started");
   loadAllState().catch((err) => {
-    log4.error("failed to load state", {
+    log6.error("failed to load state", {
       error: err instanceof Error ? err.message : String(err)
     });
     process.exit(1);
   });
   loadQueue().catch((err) => {
-    log4.error("failed to load queue", {
+    log6.error("failed to load queue", {
       error: err instanceof Error ? err.message : String(err)
     });
     process.exit(1);
   });
-  runHistoryWorker();
+  setImmediate(async () => {
+    try {
+      await runHistorySessionWorker();
+    } catch (err) {
+      log6.error("runHistorySessionWorker failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
   startTimerWorker();
 }
 var scriptPath3 = process.argv[1] || "";
@@ -2186,5 +2288,5 @@ export {
   startBatchWorker
 };
 
-//# debugId=A6D84926CC73F00864756E2164756E21
+//# debugId=2644B5BA08355EE564756E2164756E21
 //# sourceMappingURL=batchWorker.js.map