ccc-notifier 0.4.0 → 0.6.0

package/dist/sweep-RUPPGAWJ.js

@@ -0,0 +1,795 @@
+#!/usr/bin/env node
+import {
+  listCodexRollouts
+} from "./chunk-HLJAJS2W.js";
+import {
+  codexHome
+} from "./chunk-HTYUYKFW.js";
+import {
+  collectSubagentUsage
+} from "./chunk-OYD6H3ZZ.js";
+import {
+  extractBucket,
+  getUsdJpy,
+  promptCandidate,
+  splitIntoCodexTurnDrafts
+} from "./chunk-D4D76RGQ.js";
+import {
+  computeCost,
+  loadPriceTable
+} from "./chunk-6HTETN26.js";
+import {
+  writeDashboardHtml
+} from "./chunk-4JSRGJCZ.js";
+import "./chunk-DGXUSPS4.js";
+import {
+  formatJPY,
+  formatUSD,
+  modelDisplayName
+} from "./chunk-J5QAYTFE.js";
+import {
+  invalidateCanonicalDashboards,
+  makeFullDashboardState,
+  waitForDataLock,
+  writeFullDashboardStateAtomic
+} from "./chunk-27SJELD2.js";
+import {
+  appendTurn,
+  loadCursor,
+  logError,
+  paths,
+  readConfig,
+  readConfigReadOnly,
+  readTurns,
+  resetHistoryAndCursors,
+  sanitizeCursor,
+  saveCursor
+} from "./chunk-OOAC5ULQ.js";
+
+// src/sweep.ts
+import { readFile } from "fs/promises";
+import { promises as fsp } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var NEWLINE = 10;
+var MAX_SEEN_KEYS = 500;
+var SYNTHETIC_MODEL = "<synthetic>";
+var DAY_MS = 864e5;
+var SWEEP_PROGRESS_INTERVAL = 25;
+function createSweepProgressReporter() {
+  const lastSourceCount = {};
+  return (event) => {
+    if (event.type === "preparing") {
+      console.log(`\u6E96\u5099: \u5358\u4FA1\u8868\u30FB\u70BA\u66FF\u3092\u8AAD\u307F\u8FBC\u307F\u307E\u3059${event.dryRun ? " (dry-run)" : ""}`);
+      return;
+    }
+    if (event.type === "lock") {
+      console.log("lock: \u53D6\u5F97\u3092\u5F85\u3063\u3066\u3044\u307E\u3059");
+      return;
+    }
+    if (event.type === "scan-start") {
+      console.log(
+        `\u8D70\u67FB\u958B\u59CB: Claude project ${event.claudeProjects} / Codex rollout ${event.codexRollouts}`
+      );
+      return;
+    }
+    if (event.type === "source-progress") {
+      if (event.completed <= 0 || event.total <= 0) return;
+      if (event.completed % SWEEP_PROGRESS_INTERVAL !== 0) return;
+      if (lastSourceCount[event.source] === event.completed) return;
+      lastSourceCount[event.source] = event.completed;
+      const label = event.source === "claude" ? "Claude transcript" : "Codex rollout";
+      console.log(`\u8D70\u67FB\u9032\u6357: ${label} ${event.completed}/${event.total}`);
+      return;
+    }
+    if (event.type === "scan-complete") {
+      console.log(
+        `\u8D70\u67FB\u5B8C\u4E86: Claude transcript ${event.claudeTranscripts} / Codex rollout ${event.codexRollouts} / \u5BFE\u8C61 ${event.records} \u30BF\u30FC\u30F3 / \u5931\u6557 ${event.failures}`
+      );
+      return;
+    }
+    console.log("dashboard: \u751F\u6210\u958B\u59CB");
+  };
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function strOrNull(v) {
+  return typeof v === "string" ? v : null;
+}
+function emptyBuckets() {
+  return { input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 };
+}
+function addToModel(target, model, b) {
+  const cur = target[model] ?? emptyBuckets();
+  cur.input += b.input;
+  cur.output += b.output;
+  cur.cacheWrite5m += b.cacheWrite5m;
+  cur.cacheWrite1h += b.cacheWrite1h;
+  cur.cacheRead += b.cacheRead;
+  target[model] = cur;
+}
+function sumBuckets(usage) {
+  const total = emptyBuckets();
+  for (const b of Object.values(usage)) {
+    total.input += b.input;
+    total.output += b.output;
+    total.cacheWrite5m += b.cacheWrite5m;
+    total.cacheWrite1h += b.cacheWrite1h;
+    total.cacheRead += b.cacheRead;
+  }
+  return total;
+}
+function addToBuckets(target, src) {
+  target.input += src.input;
+  target.output += src.output;
+  target.cacheWrite5m += src.cacheWrite5m;
+  target.cacheWrite1h += src.cacheWrite1h;
+  target.cacheRead += src.cacheRead;
+}
+function collectModels(main, sidechain) {
+  const models = [];
+  for (const m of Object.keys(main)) if (!models.includes(m)) models.push(m);
+  for (const m of Object.keys(sidechain)) if (!models.includes(m)) models.push(m);
+  return models;
+}
+function newBuffer() {
+  return {
+    prompt: null,
+    pending: /* @__PURE__ */ new Map(),
+    sessionId: "",
+    cwd: null,
+    gitBranch: null,
+    firstTs: null,
+    lastTs: null
+  };
+}
+async function readAll(path) {
+  try {
+    return await readFile(path);
+  } catch {
+    return null;
+  }
+}
+async function splitIntoTurnDrafts(transcriptPath, cursor) {
+  const buffer = await readAll(transcriptPath);
+  if (buffer === null) {
+    const nc = cursor ?? { offset: 0, lastUuid: null, lastTs: null, seenMessageKeys: [] };
+    return { drafts: [], newCursor: nc, messageKeys: [] };
+  }
+  const fileSize = buffer.length;
+  let startOffset;
+  let rescan;
+  if (cursor !== null && cursor.offset > 0 && cursor.offset <= fileSize && buffer[cursor.offset - 1] === NEWLINE) {
+    startOffset = cursor.offset;
+    rescan = false;
+  } else {
+    startOffset = 0;
+    rescan = cursor !== null;
+  }
+  const priorSeen = new Set(cursor?.seenMessageKeys ?? []);
+  const tsFloor = cursor?.lastTs ?? null;
+  const drafts = [];
+  const runSeen = /* @__PURE__ */ new Set();
+  const newKeys = [];
+  let winLastUuid = null;
+  let winLastTs = null;
+  let cur = newBuffer();
+  const flush = () => {
+    if (cur.pending.size === 0) return;
+    const mainPerModel = {};
+    const sidechainPerModel = {};
+    for (const [key, pm] of cur.pending) {
+      runSeen.add(key);
+      newKeys.push(key);
+      if (pm.isSidechain) addToModel(sidechainPerModel, pm.model, pm.bucket);
+      else addToModel(mainPerModel, pm.model, pm.bucket);
+    }
+    drafts.push({
+      prompt: cur.prompt ?? "",
+      mainPerModel,
+      sidechainPerModel,
+      apiCalls: cur.pending.size,
+      firstTs: cur.firstTs,
+      lastTs: cur.lastTs,
+      cwd: cur.cwd,
+      gitBranch: cur.gitBranch,
+      sessionId: cur.sessionId
+    });
+  };
+  const handleLine = (raw) => {
+    if (raw.trim().length === 0) return;
+    let obj;
+    try {
+      obj = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!isRecord(obj)) return;
+    const ts = strOrNull(obj.timestamp);
+    if (rescan && tsFloor !== null && ts !== null && ts <= tsFloor) return;
+    const isSide = obj.isSidechain === true;
+    const type = obj.type;
+    const message = isRecord(obj.message) ? obj.message : null;
+    let isBoundary = false;
+    let boundaryPrompt = "";
+    if (type === "user" && !isSide && message !== null) {
+      const cand = promptCandidate(message.content);
+      if (cand !== null) {
+        const t = cand.trim();
+        if (t.length > 0 && !t.startsWith("<")) {
+          isBoundary = true;
+          boundaryPrompt = t;
+        }
+      }
+    }
+    if (isBoundary) {
+      flush();
+      cur = newBuffer();
+      cur.prompt = boundaryPrompt;
+    }
+    const sid = strOrNull(obj.sessionId);
+    if (sid !== null) cur.sessionId = sid;
+    if (!isSide) {
+      const c = strOrNull(obj.cwd);
+      if (c !== null) cur.cwd = c;
+      const gb = strOrNull(obj.gitBranch);
+      if (gb !== null) cur.gitBranch = gb;
+    }
+    if (ts !== null) {
+      if (cur.firstTs === null || ts < cur.firstTs) cur.firstTs = ts;
+      if (cur.lastTs === null || ts > cur.lastTs) cur.lastTs = ts;
+      if (winLastTs === null || ts > winLastTs) winLastTs = ts;
+    }
+    const uuid = strOrNull(obj.uuid);
+    if (uuid !== null) winLastUuid = uuid;
+    if (type === "assistant" && message !== null) {
+      const usage = message.usage;
+      if (isRecord(usage)) {
+        const rawModel = message.model;
+        if (rawModel !== SYNTHETIC_MODEL) {
+          const id = strOrNull(message.id) ?? "";
+          const reqId = strOrNull(obj.requestId) ?? "";
+          const key = `${id}:${reqId}`;
+          if (!priorSeen.has(key) && !runSeen.has(key)) {
+            const model = strOrNull(rawModel) ?? "unknown";
+            cur.pending.set(key, { model, isSidechain: isSide, bucket: extractBucket(usage) });
+          }
+        }
+      }
+    }
+  };
+  let lineStart = startOffset;
+  for (let pos = startOffset; pos < fileSize; pos++) {
+    if (buffer[pos] !== NEWLINE) continue;
+    handleLine(buffer.toString("utf8", lineStart, pos));
+    lineStart = pos + 1;
+  }
+  const newOffset = lineStart;
+  flush();
+  const combined = [...cursor?.seenMessageKeys ?? [], ...newKeys];
+  const seenMessageKeys = combined.length > MAX_SEEN_KEYS ? combined.slice(combined.length - MAX_SEEN_KEYS) : combined;
+  const newCursor = {
+    offset: newOffset,
+    lastUuid: winLastUuid,
+    lastTs: winLastTs,
+    seenMessageKeys
+  };
+  return { drafts, newCursor, messageKeys: newKeys };
+}
+function draftToRecord(draft, ts, table, fx) {
+  const breakdown = computeCost(draft.mainPerModel, draft.sidechainPerModel, table);
+  const sidechainHasModels = Object.keys(draft.sidechainPerModel).length > 0;
+  const rec = {
+    schemaVersion: 1,
+    ts,
+    sessionId: draft.sessionId,
+    project: draft.cwd ?? "",
+    gitBranch: draft.gitBranch,
+    models: collectModels(draft.mainPerModel, draft.sidechainPerModel),
+    tokens: sumBuckets(draft.mainPerModel),
+    sidechainTokens: sidechainHasModels ? sumBuckets(draft.sidechainPerModel) : null,
+    apiCalls: draft.apiCalls,
+    costUSD: breakdown.usd,
+    costByModel: breakdown.byModel,
+    costJPY: breakdown.usd * fx.rate,
+    // 円換算は sweep 実行時レート
+    fxRate: fx.rate,
+    fxSource: fx.source,
+    prompt: draft.prompt,
+    ingest: "sweep"
+  };
+  if (breakdown.unknownModels.length > 0) rec.unknownModels = breakdown.unknownModels;
+  return rec;
+}
+function mergeUnknownModels(rec, extra) {
+  if (extra.length === 0) return;
+  const merged = rec.unknownModels ? [...rec.unknownModels] : [];
+  for (const m of extra) if (!merged.includes(m)) merged.push(m);
+  rec.unknownModels = merged;
+}
+async function processTranscriptLocked(mainPath, table, fx, daysCutoff, dryRun, summary, opts = {}) {
+  if (opts.strictRead) {
+    const file = await fsp.open(mainPath, "r");
+    await file.close();
+  }
+  const cursor = opts.ignoreCursors ? null : sanitizeCursor(loadCursor(mainPath));
+  const { drafts, newCursor, messageKeys } = await splitIntoTurnDrafts(mainPath, cursor);
+  const records = [];
+  for (const draft of drafts) {
+    const ts = draft.lastTs ?? (/* @__PURE__ */ new Date()).toISOString();
+    if (daysCutoff !== null) {
+      const tsMs = Date.parse(ts);
+      if (!Number.isFinite(tsMs) || tsMs < daysCutoff) continue;
+    }
+    records.push(draftToRecord(draft, ts, table, fx));
+  }
+  let sa = null;
+  try {
+    sa = await collectSubagentUsage(mainPath, {
+      ignoreCursors: opts.ignoreCursors,
+      strictRead: opts.strictRead,
+      includeAllFiles: opts.ignoreCursors,
+      excludeMessageKeys: new Set(messageKeys),
+      minTimestampMs: daysCutoff
+    });
+  } catch (err) {
+    if (opts.strictRead) throw err;
+    logError("sweep:subagents", err);
+    sa = null;
+  }
+  const saHasUsage = sa !== null && sa.apiCalls > 0;
+  if (saHasUsage) {
+    const parentRecords = [...records];
+    for (const group of sa.groups) {
+      const saBreakdown = computeCost(group.perModel, {}, table);
+      summary.subagentsUSD += saBreakdown.usd;
+      const saBlock = {
+        costUSD: saBreakdown.usd,
+        costByModel: { ...saBreakdown.byModel },
+        tokens: sumBuckets(group.perModel),
+        apiCalls: group.apiCalls,
+        agentFiles: 1
+      };
+      const groupMs = group.lastTs === null ? NaN : Date.parse(group.lastTs);
+      let target;
+      if (Number.isFinite(groupMs)) {
+        target = parentRecords.find((rec) => {
+          const recMs = Date.parse(rec.ts);
+          return Number.isFinite(recMs) && recMs >= groupMs;
+        });
+      } else {
+        target = parentRecords[parentRecords.length - 1];
+      }
+      if (target === void 0) {
+        target = {
+          schemaVersion: 1,
+          ts: group.lastTs ?? sa.lastTs ?? (/* @__PURE__ */ new Date()).toISOString(),
+          sessionId: sa.sessionId,
+          project: sa.cwd ?? "",
+          gitBranch: sa.gitBranch,
+          models: collectModels(group.perModel, {}),
+          tokens: emptyBuckets(),
+          sidechainTokens: null,
+          apiCalls: 0,
+          costUSD: 0,
+          costByModel: {},
+          costJPY: 0,
+          fxRate: fx.rate,
+          fxSource: fx.source,
+          prompt: "",
+          ingest: "sweep"
+        };
+        records.push(target);
+      }
+      if (target.subagents === void 0) {
+        target.subagents = saBlock;
+      } else {
+        target.subagents.costUSD += saBlock.costUSD;
+        target.subagents.apiCalls += saBlock.apiCalls;
+        target.subagents.agentFiles += 1;
+        addToBuckets(target.subagents.tokens, saBlock.tokens);
+        for (const [model, usd] of Object.entries(saBlock.costByModel)) {
+          target.subagents.costByModel[model] = (target.subagents.costByModel[model] ?? 0) + usd;
+        }
+      }
+      mergeUnknownModels(target, saBreakdown.unknownModels);
+    }
+    summary.agentFiles += sa.agentFiles;
+  }
+  for (const rec of records) {
+    summary.newRecords += 1;
+    summary.totalUSD += rec.costUSD;
+    if (rec.costByModel) {
+      for (const [m, c] of Object.entries(rec.costByModel)) {
+        summary.byModel[m] = (summary.byModel[m] ?? 0) + c;
+      }
+    }
+  }
+  if (!dryRun) {
+    for (const rec of records) appendTurn(rec);
+    if (drafts.length > 0) saveCursor(mainPath, newCursor);
+    if (sa !== null) {
+      for (const nc of sa.newCursors) saveCursor(nc.path, nc.cursor);
+    }
+  }
+}
+function codexDraftToRecord(draft, ts, table, fx) {
+  const main = draft.agg.main;
+  const breakdown = computeCost(main, {}, table);
+  const rec = {
+    schemaVersion: 1,
+    ts,
+    sessionId: draft.agg.sessionId,
+    project: draft.agg.cwd ?? "",
+    gitBranch: null,
+    // rollout に git 情報は無い
+    models: collectModels(main, {}),
+    tokens: sumBuckets(main),
+    sidechainTokens: null,
+    apiCalls: draft.agg.apiCalls,
+    costUSD: breakdown.usd,
+    costByModel: breakdown.byModel,
+    costJPY: breakdown.usd * fx.rate,
+    // 円換算は sweep 実行時レート(Claude 側と同じ)
+    fxRate: fx.rate,
+    fxSource: fx.source,
+    prompt: draft.agg.prompt ?? "",
+    ingest: "sweep",
+    source: "codex"
+  };
+  if (breakdown.unknownModels.length > 0) rec.unknownModels = breakdown.unknownModels;
+  return rec;
+}
+async function processCodexRolloutLocked(rolloutPath, table, fx, daysCutoff, dryRun, summary, opts = {}) {
+  if (opts.strictRead) {
+    const file = await fsp.open(rolloutPath, "r");
+    await file.close();
+  }
+  const cursor = opts.ignoreCursors ? null : sanitizeCursor(loadCursor(rolloutPath));
+  const drafts = await splitIntoCodexTurnDrafts(rolloutPath, cursor);
+  if (drafts === null || drafts.length === 0) return;
+  if (drafts[0].isSubagentRollout) return;
+  const records = [];
+  for (const draft of drafts) {
+    const ts = draft.endTs ?? (/* @__PURE__ */ new Date()).toISOString();
+    if (daysCutoff !== null) {
+      const tsMs = Date.parse(ts);
+      if (!Number.isFinite(tsMs) || tsMs < daysCutoff) continue;
+    }
+    records.push(codexDraftToRecord(draft, ts, table, fx));
+  }
+  for (const rec of records) {
+    summary.newRecords += 1;
+    summary.totalUSD += rec.costUSD;
+    summary.codexRecords += 1;
+    summary.codexUSD += rec.costUSD;
+    if (rec.costByModel) {
+      for (const [m, c] of Object.entries(rec.costByModel)) {
+        summary.byModel[m] = (summary.byModel[m] ?? 0) + c;
+      }
+    }
+  }
+  if (!dryRun) {
+    for (const rec of records) appendTurn(rec);
+    saveCursor(rolloutPath, drafts[drafts.length - 1].agg.newCursor);
+  }
+}
+function isMissingPathError(err) {
+  return err?.code === "ENOENT";
+}
+async function discoverCodexSweepSource() {
+  const home = codexHome();
+  let homeStat;
+  try {
+    homeStat = await fsp.lstat(home);
+  } catch (err) {
+    if (isMissingPathError(err)) return null;
+    return { discovery: { rollouts: [], unreadableDirs: 1 } };
+  }
+  if (!homeStat.isDirectory()) {
+    return { discovery: { rollouts: [], unreadableDirs: 1 } };
+  }
+  const sessionsRoot = join(home, "sessions");
+  try {
+    await fsp.lstat(sessionsRoot);
+  } catch (err) {
+    if (isMissingPathError(err)) return null;
+    return { discovery: { rollouts: [], unreadableDirs: 1 } };
+  }
+  return { discovery: await listCodexRollouts(sessionsRoot) };
+}
+function projectsRoot(override) {
+  if (override) return override;
+  return process.env.CCCN_CLAUDE_PROJECTS || join(homedir(), ".claude", "projects");
+}
+function parseSweepFlags(argv) {
+  const flags = {
+    dryRun: false,
+    days: null,
+    projects: null
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--dry-run") {
+      flags.dryRun = true;
+    } else if (a === "--days" || a.startsWith("--days=")) {
+      const v = a.includes("=") ? a.slice("--days=".length) : argv[++i];
+      if (v === void 0 || v.length === 0) return { error: "--days \u306B\u306F\u5024\u304C\u5FC5\u8981\u3067\u3059" };
+      const n = Number(v);
+      if (!Number.isFinite(n) || n < 0) return { error: "--days \u306F0\u4EE5\u4E0A\u306E\u6570\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044" };
+      flags.days = n;
+    } else if (a === "--projects" || a.startsWith("--projects=")) {
+      const v = a.includes("=") ? a.slice("--projects=".length) : argv[++i];
+      if (!v) return { error: "--projects \u306B\u306F\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u304C\u5FC5\u8981\u3067\u3059" };
+      flags.projects = v;
+    } else {
+      return { error: `\u4E0D\u660E\u306Aoption\u307E\u305F\u306F\u4F59\u5206\u306A\u5F15\u6570\u3067\u3059: ${a}` };
+    }
+  }
+  return { flags };
+}
+async function listProjectDirs(root) {
+  try {
+    const entries = await fsp.readdir(root, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => join(root, e.name));
+  } catch {
+    return null;
+  }
+}
+async function listTranscriptsStrict(projectDir) {
+  try {
+    const entries = await fsp.readdir(projectDir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join(projectDir, e.name));
+  } catch {
+    return null;
+  }
+}
+function printSweepSummary(summary, fx) {
+  if (summary.dryRun) {
+    console.log("(dry-run: \u66F8\u304D\u8FBC\u307F\u306F\u884C\u3063\u3066\u3044\u307E\u305B\u3093)");
+  }
+  console.log(
+    `\u8D70\u67FB: \u30D7\u30ED\u30B8\u30A7\u30AF\u30C8 ${summary.projects} / transcript ${summary.transcripts} / \u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u30D5\u30A1\u30A4\u30EB ${summary.agentFiles}`
+  );
+  if (summary.newRecords === 0) {
+    console.log("\u518D\u751F\u6210\u5BFE\u8C61\u306F\u3042\u308A\u307E\u305B\u3093\u3067\u3057\u305F");
+  } else {
+    console.log(
+      `\u518D\u751F\u6210: ${summary.newRecords} \u30BF\u30FC\u30F3\u3001\u5408\u8A08 ${formatUSD(summary.totalUSD)}(${formatJPY(summary.totalJPY)})`
+    );
+    if (summary.subagentsUSD > 0) {
+      console.log(
+        `  \u3046\u3061\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8: ${formatUSD(summary.subagentsUSD)}(${formatJPY(summary.subagentsUSD * fx.rate)})`
+      );
+    }
+    if (summary.codexRecords > 0) {
+      console.log(
+        `  Codex: ${summary.codexRecords} \u30BF\u30FC\u30F3 ${formatUSD(summary.codexUSD)}(${formatJPY(summary.codexUSD * fx.rate)})`
+      );
+    }
+    const top = Object.entries(summary.byModel).filter(([, c]) => c > 0).sort((a, b) => b[1] - a[1]).slice(0, 5);
+    if (top.length > 0) {
+      console.log("  \u30E2\u30C7\u30EB\u5225(\u4E0A\u4F4D):");
+      for (const [m, c] of top) {
+        console.log(`    ${modelDisplayName(m)}: ${formatUSD(c)}`);
+      }
+    }
+  }
+  console.log(`\u5186\u63DB\u7B97\u30EC\u30FC\u30C8: 1USD = ${fx.rate}JPY(source=${fx.source})`);
+}
+function reportSourceFailure(summary, dryRun, scope, err, count = 1) {
+  summary.sourceFailures += count;
+  if (dryRun) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`${scope}: ${message}`);
+    return;
+  }
+  logError(scope, err);
+}
+async function scanAllSources(projectDirs, codexSource, table, fx, daysCutoff, dryRun, summary, progress) {
+  const codexRollouts = codexSource?.discovery.rollouts.length ?? 0;
+  progress({
+    type: "scan-start",
+    claudeProjects: projectDirs?.length ?? 0,
+    codexRollouts
+  });
+  const transcriptPaths = [];
+  for (const projectDir of projectDirs ?? []) {
+    const transcripts = await listTranscriptsStrict(projectDir);
+    if (transcripts === null) {
+      reportSourceFailure(
+        summary,
+        dryRun,
+        "sweep:discovery",
+        new Error(`cannot read project: ${projectDir}`)
+      );
+      continue;
+    }
+    transcriptPaths.push(...transcripts);
+  }
+  for (const mainPath of transcriptPaths) {
+    summary.transcripts += 1;
+    try {
+      await processTranscriptLocked(mainPath, table, fx, daysCutoff, dryRun, summary, {
+        ignoreCursors: true,
+        strictRead: true
+      });
+    } catch (err) {
+      reportSourceFailure(summary, dryRun, "sweep:transcript", err);
+    }
+    progress({
+      type: "source-progress",
+      source: "claude",
+      completed: summary.transcripts,
+      total: transcriptPaths.length
+    });
+  }
+  let completedCodexRollouts = 0;
+  if (codexSource !== null) {
+    const { discovery } = codexSource;
+    if (discovery.unreadableDirs > 0) {
+      reportSourceFailure(
+        summary,
+        dryRun,
+        "sweep:codex-discovery",
+        new Error(`${discovery.unreadableDirs} directories could not be read`),
+        discovery.unreadableDirs
+      );
+    }
+    for (const rolloutPath of discovery.rollouts) {
+      try {
+        await processCodexRolloutLocked(rolloutPath, table, fx, daysCutoff, dryRun, summary, {
+          ignoreCursors: true,
+          strictRead: true
+        });
+      } catch (err) {
+        reportSourceFailure(summary, dryRun, "sweep:codex", err);
+      }
+      completedCodexRollouts += 1;
+      progress({
+        type: "source-progress",
+        source: "codex",
+        completed: completedCodexRollouts,
+        total: codexRollouts
+      });
+    }
+  }
+  progress({
+    type: "scan-complete",
+    claudeTranscripts: summary.transcripts,
+    codexRollouts: completedCodexRollouts,
+    records: summary.newRecords,
+    failures: summary.sourceFailures
+  });
+}
+async function runSweep(argv, deps = {}) {
+  const parsed = parseSweepFlags(argv);
+  if ("error" in parsed) {
+    console.error(`${parsed.error}
+\u4F7F\u3044\u65B9 / Usage: ccc-notifier sweep [--dry-run] [--days N] [--projects DIR]`);
+    return 1;
+  }
+  const flags = parsed.flags;
+  const progress = createSweepProgressReporter();
+  const root = projectsRoot(flags.projects);
+  const projectDirs = await listProjectDirs(root);
+  const codexSource = await discoverCodexSweepSource();
+  if (projectDirs === null) {
+    if (codexSource === null || codexSource.discovery.unreadableDirs > 0) {
+      console.log(`\u8D70\u67FB\u30EB\u30FC\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${root}`);
+      return 1;
+    }
+    console.log(`Claude \u306E\u8D70\u67FB\u30EB\u30FC\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${root}(Codex \u306E\u307F\u8D70\u67FB\u3057\u307E\u3059)`);
+  }
+  progress({ type: "preparing", dryRun: flags.dryRun });
+  const cfg = flags.dryRun ? readConfigReadOnly((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`sweep:config: ${message}(\u65E2\u5B9A\u5024\u3067\u7D9A\u884C\u3057\u307E\u3059)`);
+  }) : readConfig();
+  const cacheDir = paths().cacheDir;
+  const table = await loadPriceTable(cacheDir, { offline: false });
+  const fx = await getUsdJpy(cfg, cacheDir);
+  const summary = {
+    projects: projectDirs === null ? 0 : projectDirs.length,
+    transcripts: 0,
+    agentFiles: 0,
+    newRecords: 0,
+    totalUSD: 0,
+    totalJPY: 0,
+    subagentsUSD: 0,
+    byModel: {},
+    codexRecords: 0,
+    codexUSD: 0,
+    dryRun: flags.dryRun,
+    sourceFailures: 0
+  };
+  const daysCutoff = flags.days !== null ? Date.now() - flags.days * DAY_MS : null;
+  const lockProvider = deps.lockProvider ?? (() => waitForDataLock());
+  if (flags.dryRun) {
+    try {
+      await scanAllSources(projectDirs, codexSource, table, fx, daysCutoff, true, summary, progress);
+    } catch (err) {
+      reportSourceFailure(summary, true, "sweep:dry-run", err);
+    }
+    summary.totalJPY = summary.totalUSD * fx.rate;
+    printSweepSummary(summary, fx);
+    if (summary.sourceFailures > 0) {
+      console.error(
+        `\u4E00\u90E8\u3092\u8D70\u67FB\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F(${summary.sourceFailures}\u4EF6\u5931\u6557)\u3002source\u3092\u78BA\u8A8D\u3057\u3066\u540C\u3058 ccc-notifier sweep --dry-run \u3092\u518D\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044`
+      );
+      return 1;
+    }
+    return 0;
+  }
+  progress({ type: "lock" });
+  const lock = await lockProvider();
+  if (lock === null) {
+    console.error("\u5168\u518D\u751F\u6210\u306Edata lock\u3092\u53D6\u5F97\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5F8C\u3067\u3082\u3046\u4E00\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044");
+    return 1;
+  }
+  let dashboardFailure = false;
+  try {
+    invalidateCanonicalDashboards();
+    resetHistoryAndCursors();
+    await scanAllSources(projectDirs, codexSource, table, fx, daysCutoff, false, summary, progress);
+    try {
+      invalidateCanonicalDashboards();
+      if (summary.sourceFailures === 0 && cfg.dashboard.autoRegenerate) {
+        progress({ type: "dashboard-start" });
+        const generatedAt = /* @__PURE__ */ new Date();
+        const generatedAtIso = generatedAt.toISOString();
+        const allTurns = readTurns();
+        writeDashboardHtml({
+          days: cfg.dashboard.days,
+          outPath: paths().recentDashboardFile,
+          autoReloadSec: cfg.dashboard.autoReloadSec,
+          allTurns,
+          variant: "recent",
+          generatedAt: generatedAtIso
+        });
+        writeDashboardHtml({
+          days: null,
+          outPath: paths().fullDashboardFile,
+          autoReloadSec: cfg.dashboard.autoReloadSec,
+          allTurns,
+          variant: "full",
+          generatedAt: generatedAtIso
+        });
+        writeFullDashboardStateAtomic(makeFullDashboardState(generatedAt));
+      }
+    } catch (err) {
+      dashboardFailure = true;
+      logError("sweep:dashboard", err);
+      try {
+        invalidateCanonicalDashboards();
+      } catch (invalidateErr) {
+        logError("sweep:dashboard-invalidate", invalidateErr);
+      }
+    }
+  } catch (err) {
+    reportSourceFailure(summary, false, "sweep", err);
+  } finally {
+    lock.release();
+  }
+  summary.totalJPY = summary.totalUSD * fx.rate;
+  printSweepSummary(summary, fx);
+  if (summary.sourceFailures > 0) {
+    console.error(
+      `\u4E00\u90E8\u518D\u751F\u6210\u3067\u3059(${summary.sourceFailures}\u4EF6\u5931\u6557)\u3002\u540C\u3058 ccc-notifier sweep \u3092\u518D\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044 / partial regeneration; retry`
+    );
+    return 1;
+  }
+  if (dashboardFailure) {
+    console.error(
+      "\u5C65\u6B74\u306F\u518D\u751F\u6210\u6E08\u307F\u3067\u3059\u304C\u3001\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u3092\u751F\u6210\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002ccc-notifier dashboard \u3068 ccc-notifier dashboard --all \u3092\u624B\u52D5\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044"
+    );
+    return 1;
+  }
+  console.log("\u5C65\u6B74\u3068\u53D6\u308A\u8FBC\u307F\u4F4D\u7F6E\u3092\u5143JSONL\u304B\u3089\u5168\u518D\u751F\u6210\u3057\u307E\u3057\u305F");
+  return 0;
+}
+export {
+  runSweep,
+  splitIntoTurnDrafts
+};