ccc-notifier 0.6.2 → 0.7.0

package/dist/{chunk-27SJELD2.js → chunk-PXMXEFM7.js}

@@ -1,100 +1,19 @@
 #!/usr/bin/env node
 import {
   paths
-} from "./chunk-OOAC5ULQ.js";
+} from "./chunk-WONMZ466.js";
 
-// src/dashboard-state.ts
+// src/data-lock.ts
+import { randomUUID } from "crypto";
+import { hostname } from "os";
 import {
-  closeSync,
   existsSync,
-  openSync,
+  mkdirSync,
   readFileSync,
-  readSync,
   renameSync,
   rmSync,
   writeFileSync
 } from "fs";
-import { randomUUID } from "crypto";
-function localDate(now) {
-  const y = now.getFullYear();
-  const m = String(now.getMonth() + 1).padStart(2, "0");
-  const d = String(now.getDate()).padStart(2, "0");
-  return `${y}-${m}-${d}`;
-}
-function timeZone() {
-  return Intl.DateTimeFormat().resolvedOptions().timeZone || "unknown";
-}
-function makeFullDashboardState(now = /* @__PURE__ */ new Date()) {
-  return { localDate: localDate(now), timeZone: timeZone(), generatedAt: now.toISOString() };
-}
-function readState() {
-  const file = paths().dashboardFullStateFile;
-  if (!existsSync(file)) return null;
-  try {
-    const value = JSON.parse(readFileSync(file, "utf8"));
-    if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
-    const v = value;
-    if (typeof v.localDate !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(v.localDate) || typeof v.timeZone !== "string" || v.timeZone.length === 0 || typeof v.generatedAt !== "string" || !Number.isFinite(Date.parse(v.generatedAt))) {
-      return null;
-    }
-    return v;
-  } catch {
-    return null;
-  }
-}
-function isFullDashboardDue(now = /* @__PURE__ */ new Date()) {
-  const p = paths();
-  if (!existsSync(p.fullDashboardFile)) return true;
-  try {
-    const fd = openSync(p.fullDashboardFile, "r");
-    try {
-      const head = Buffer.alloc(512);
-      const n = readSync(fd, head, 0, head.length, 0);
-      if (head.toString("utf8", 0, n).includes('name="cccn-placeholder"')) return true;
-    } finally {
-      closeSync(fd);
-    }
-  } catch {
-    return true;
-  }
-  const state = readState();
-  if (state === null) return true;
-  const expected = makeFullDashboardState(now);
-  if (state.timeZone !== expected.timeZone) return true;
-  if (state.localDate !== expected.localDate) return true;
-  if (state.localDate > expected.localDate) return true;
-  if (Date.parse(state.generatedAt) > now.getTime()) return true;
-  return false;
-}
-function writeFullDashboardStateAtomic(state) {
-  const file = paths().dashboardFullStateFile;
-  const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
-  try {
-    writeFileSync(tmp, `${JSON.stringify(state)}
-`, "utf8");
-    renameSync(tmp, file);
-  } finally {
-    rmSync(tmp, { force: true });
-  }
-}
-function invalidateCanonicalDashboards() {
-  const p = paths();
-  for (const file of [p.recentDashboardFile, p.fullDashboardFile, p.dashboardFullStateFile]) {
-    rmSync(file, { force: true });
-  }
-}
-
-// src/data-lock.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { hostname } from "os";
-import {
-  existsSync as existsSync2,
-  mkdirSync,
-  readFileSync as readFileSync2,
-  renameSync as renameSync2,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync2
-} from "fs";
 import { join } from "path";
 var DATA_LOCK_LEASE_MS = 3e4;
 var HEARTBEAT_MS = 5e3;
@@ -103,7 +22,7 @@ function ownerFile(dir) {
 }
 function readOwner(dir) {
   try {
-    const v = JSON.parse(readFileSync2(ownerFile(dir), "utf8"));
+    const v = JSON.parse(readFileSync(ownerFile(dir), "utf8"));
     if (typeof v.token !== "string" || typeof v.pid !== "number" || typeof v.hostname !== "string" || typeof v.acquiredAt !== "string" || typeof v.heartbeatAt !== "string") return null;
     return v;
   } catch {
@@ -111,21 +30,21 @@ function readOwner(dir) {
   }
 }
 function writeOwner(dir, owner) {
-  const tmp = join(dir, `owner.${owner.token}.${randomUUID2()}.tmp`);
+  const tmp = join(dir, `owner.${owner.token}.${randomUUID()}.tmp`);
   try {
-    writeFileSync2(tmp, `${JSON.stringify(owner)}
+    writeFileSync(tmp, `${JSON.stringify(owner)}
 `, "utf8");
-    renameSync2(tmp, ownerFile(dir));
+    renameSync(tmp, ownerFile(dir));
   } finally {
-    rmSync2(tmp, { force: true });
+    rmSync(tmp, { force: true });
   }
 }
 function quarantineOwned(dir, token, label) {
   const before = readOwner(dir);
   if (before?.token !== token) return false;
-  const quarantine = `${dir}.${label}-${token}-${randomUUID2()}`;
+  const quarantine = `${dir}.${label}-${token}-${randomUUID()}`;
   try {
-    renameSync2(dir, quarantine);
+    renameSync(dir, quarantine);
   } catch {
     return false;
   }
@@ -133,21 +52,21 @@ function quarantineOwned(dir, token, label) {
   if (moved?.token !== token) {
     return false;
   }
-  rmSync2(quarantine, { recursive: true, force: true });
+  rmSync(quarantine, { recursive: true, force: true });
   return true;
 }
 function claimDir(fixed, label, now, metadataWriter = writeOwner) {
-  const token = randomUUID2();
+  const token = randomUUID();
   const staging = `${fixed}.${label}-${token}`;
   const iso = now.toISOString();
   const owner = { token, pid: process.pid, hostname: hostname(), acquiredAt: iso, heartbeatAt: iso };
   try {
     mkdirSync(staging);
     metadataWriter(staging, owner);
-    renameSync2(staging, fixed);
+    renameSync(staging, fixed);
     return { token, owner };
   } catch {
-    rmSync2(staging, { recursive: true, force: true });
+    rmSync(staging, { recursive: true, force: true });
     return null;
   }
 }
@@ -180,15 +99,15 @@ function tryReclaim(now, leaseMs) {
     if (!processDefinitelyDead(first.pid)) return false;
     const second = readOwner(p.dataLockDir);
     if (second === null || second.token !== first.token || second.heartbeatAt !== first.heartbeatAt) return false;
-    const orphan = `${p.dataLockDir}.orphan-${first.token}-${randomUUID2()}`;
+    const orphan = `${p.dataLockDir}.orphan-${first.token}-${randomUUID()}`;
     try {
-      renameSync2(p.dataLockDir, orphan);
+      renameSync(p.dataLockDir, orphan);
     } catch {
       return false;
     }
     const moved = readOwner(orphan);
     if (moved?.token !== first.token || moved.heartbeatAt !== first.heartbeatAt) return false;
-    rmSync2(orphan, { recursive: true, force: true });
+    rmSync(orphan, { recursive: true, force: true });
     return true;
   } finally {
     quarantineOwned(p.dataReclaimDir, guard.token, "released");
@@ -198,15 +117,15 @@ function acquireDataLock(opts = {}) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const leaseMs = opts.leaseMs ?? DATA_LOCK_LEASE_MS;
   const p = paths();
-  if (existsSync2(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) return null;
+  if (existsSync(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) return null;
   let claim = claimDir(p.dataLockDir, "acquire", now, opts.metadataWriter);
   if (claim === null) {
     if (!tryReclaim(now, leaseMs)) return null;
-    if (existsSync2(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) return null;
+    if (existsSync(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) return null;
     claim = claimDir(p.dataLockDir, "acquire", now, opts.metadataWriter);
     if (claim === null) return null;
   }
-  if (existsSync2(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) {
+  if (existsSync(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) {
     quarantineOwned(p.dataLockDir, claim.token, "yielded");
     return null;
   }
@@ -249,9 +168,5 @@ async function waitForDataLock(timeoutMs, pollMs = 25) {
 }
 
 export {
-  makeFullDashboardState,
-  isFullDashboardDue,
-  writeFullDashboardStateAtomic,
-  invalidateCanonicalDashboards,
   waitForDataLock
 };

package/dist/{chunk-6HTETN26.js → chunk-Q45AAPJY.js}

@@ -220,7 +220,24 @@ async function loadPriceTable(cacheDir, opts) {
   }
 }
 
+// src/codex/env.ts
+import { statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function codexHome() {
+  return process.env.CCCN_CODEX_HOME || join(homedir(), ".codex");
+}
+function detectCodex() {
+  try {
+    return statSync(codexHome()).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
 export {
   computeCost,
-  loadPriceTable
+  loadPriceTable,
+  codexHome,
+  detectCodex
 };

package/dist/chunk-V4IS4FXH.js

@@ -0,0 +1,454 @@
+#!/usr/bin/env node
+import {
+  notifyOS,
+  notifySlack
+} from "./chunk-JLDI4D5E.js";
+import {
+  attachSubagentGroups,
+  collectSubagentUsage,
+  normalizeCodexOriginator,
+  splitIntoTurnDrafts
+} from "./chunk-6BXD6HU5.js";
+import {
+  anyOf,
+  callFingerprints,
+  claudeTranscriptRoots,
+  codexResumePointAtTs,
+  getUsdJpy,
+  listCodexRollouts,
+  messageKeyFilterOf,
+  scanCodexTurns,
+  setCountedCalls,
+  surfaceForClaudePath
+} from "./chunk-OCKZZVOG.js";
+import {
+  codexHome,
+  computeCost,
+  loadPriceTable
+} from "./chunk-Q45AAPJY.js";
+import {
+  waitForDataLock
+} from "./chunk-PXMXEFM7.js";
+import {
+  formatIngestSummary
+} from "./chunk-XG73C6CC.js";
+import {
+  appendTurn,
+  floorKey,
+  isMuted,
+  loadAllCursors,
+  loadHistoryIndex,
+  logError,
+  paths,
+  readConfig,
+  readConfigReadOnly,
+  sanitizeCursor,
+  saveAllCursors
+} from "./chunk-WONMZ466.js";
+
+// src/ingest.ts
+import { promises as fsp, readFileSync, renameSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+function emptyBuckets() {
+  return { input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 };
+}
+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 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;
+}
+async function listProjectDirsBestEffort(root) {
+  try {
+    const entries = await fsp.readdir(root, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => join(root, e.name));
+  } catch {
+    return [];
+  }
+}
+async function listTranscriptsBestEffort(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 [];
+  }
+}
+async function discoverClaudeFiles(roots) {
+  const files = [];
+  for (const root of roots) {
+    for (const dir of await listProjectDirsBestEffort(root.path)) {
+      files.push(...await listTranscriptsBestEffort(dir));
+    }
+  }
+  return files;
+}
+async function discoverCodexFiles() {
+  const sessionsRoot = join(codexHome(), "sessions");
+  try {
+    const stat = await fsp.lstat(sessionsRoot);
+    if (!stat.isDirectory()) return [];
+  } catch {
+    return [];
+  }
+  try {
+    const discovery = await listCodexRollouts(sessionsRoot);
+    return discovery.rollouts;
+  } catch {
+    return [];
+  }
+}
+function ingestMtimeCachePath() {
+  return join(paths().cacheDir, "ingest-mtimes.json");
+}
+function loadIngestMtimeCache() {
+  try {
+    const raw = readFileSync(ingestMtimeCachePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function saveIngestMtimeCache(cache) {
+  try {
+    const file = ingestMtimeCachePath();
+    const tmp = `${file}.tmp`;
+    writeFileSync(tmp, JSON.stringify(cache), "utf8");
+    renameSync(tmp, file);
+  } catch {
+  }
+}
+async function fileMtimeMs(filePath) {
+  return (await fsp.stat(filePath)).mtimeMs;
+}
+async function claudeMtimeSignature(filePath) {
+  let newest = (await fsp.stat(filePath)).mtimeMs;
+  const dir = join(
+    filePath.endsWith(".jsonl") ? filePath.slice(0, -".jsonl".length) : filePath,
+    "subagents"
+  );
+  let entries;
+  try {
+    entries = await fsp.readdir(dir, { withFileTypes: true });
+  } catch (err) {
+    if (err?.code === "ENOENT") return newest;
+    throw err;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.startsWith("agent-") || !entry.name.endsWith(".jsonl")) continue;
+    try {
+      const m = (await fsp.stat(join(dir, entry.name))).mtimeMs;
+      if (m > newest) newest = m;
+    } catch (err) {
+      if (err?.code !== "ENOENT") throw err;
+    }
+  }
+  return newest;
+}
+function recoveryCursor(floorTs) {
+  return { offset: 0, lastUuid: null, lastTs: floorTs, seenMessageKeys: [] };
+}
+function buildClaudeDraftRecord(draft, ts, table, fx, surface) {
+  const main = draft.mainPerModel;
+  const sidechain = draft.sidechainPerModel;
+  const breakdown = computeCost(main, sidechain, table);
+  const sidechainHasModels = Object.keys(sidechain).length > 0;
+  const rec = {
+    schemaVersion: 1,
+    ts,
+    sessionId: draft.sessionId,
+    project: draft.cwd ?? "",
+    gitBranch: draft.gitBranch,
+    models: collectModels(main, sidechain),
+    tokens: sumBuckets(main),
+    sidechainTokens: sidechainHasModels ? sumBuckets(sidechain) : null,
+    apiCalls: draft.apiCalls,
+    costUSD: breakdown.usd,
+    costByModel: breakdown.byModel,
+    costJPY: breakdown.usd * fx.rate,
+    fxRate: fx.rate,
+    fxSource: fx.source,
+    prompt: draft.prompt,
+    ingest: "scan",
+    surface
+  };
+  if (breakdown.unknownModels.length > 0) rec.unknownModels = breakdown.unknownModels;
+  setCountedCalls(rec, callFingerprints(draft.messageKeys));
+  return rec;
+}
+function sessionIdOfDrafts(drafts) {
+  for (let i = drafts.length - 1; i >= 0; i--) {
+    if (drafts[i].sessionId.length > 0) return drafts[i].sessionId;
+  }
+  return "";
+}
+function sessionIdFromTranscriptPath(filePath) {
+  const name = basename(filePath);
+  return name.endsWith(".jsonl") ? name.slice(0, -".jsonl".length) : "";
+}
+function buildCodexRecord(agg, table, fx) {
+  const main = agg.main;
+  const breakdown = computeCost(main, {}, table);
+  const surface = normalizeCodexOriginator(agg.originator);
+  const rec = {
+    schemaVersion: 1,
+    ts: agg.lastTs ?? (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: agg.sessionId,
+    project: agg.cwd ?? "",
+    gitBranch: null,
+    models: collectModels(main, {}),
+    tokens: sumBuckets(main),
+    sidechainTokens: null,
+    apiCalls: agg.apiCalls,
+    costUSD: breakdown.usd,
+    costByModel: breakdown.byModel,
+    costJPY: breakdown.usd * fx.rate,
+    fxRate: fx.rate,
+    fxSource: fx.source,
+    prompt: agg.prompt ?? "",
+    ingest: "scan",
+    source: "codex",
+    surface
+  };
+  if (typeof agg.originator === "string") rec.originator = agg.originator;
+  if (breakdown.unknownModels.length > 0) rec.unknownModels = breakdown.unknownModels;
+  setCountedCalls(rec, agg.codexEventKeys ?? []);
+  return rec;
+}
+function emptyResult(dryRun, fx, lockAcquired) {
+  return {
+    dryRun,
+    lockAcquired,
+    records: [],
+    scannedFiles: 0,
+    skippedByMtime: 0,
+    skippedDuplicates: 0,
+    failures: 0,
+    totalUSD: 0,
+    totalJPY: 0,
+    fxRate: fx.rate,
+    fxSource: fx.source,
+    bySurface: {}
+  };
+}
+function addRecord(result, rec) {
+  const usd = rec.costUSD + (rec.subagents?.costUSD ?? 0);
+  const jpy = rec.costJPY + (rec.subagents?.costUSD ?? 0) * rec.fxRate;
+  result.records.push(rec);
+  result.totalUSD += usd;
+  result.totalJPY += jpy;
+  const surface = rec.surface ?? "cli";
+  const cur = result.bySurface[surface] ?? { turns: 0, usd: 0 };
+  cur.turns += 1;
+  cur.usd += usd;
+  result.bySurface[surface] = cur;
+}
+async function runIngest(opts) {
+  const dryRun = opts.dryRun;
+  const cfg = opts.cfg ?? (dryRun ? readConfigReadOnly() : readConfig());
+  const cacheDir = paths().cacheDir;
+  const table = await loadPriceTable(cacheDir, { offline: opts.offlinePricing ?? true });
+  const fx = await getUsdJpy(cfg, cacheDir);
+  const claudeRoots = opts.claudeRoots ?? await claudeTranscriptRoots();
+  const includeCodex = opts.includeCodex ?? true;
+  const claudeFiles = await discoverClaudeFiles(claudeRoots);
+  const codexFiles = includeCodex ? await discoverCodexFiles() : [];
+  if (dryRun) {
+    return await processFiles(claudeFiles, codexFiles, claudeRoots, table, fx, true);
+  }
+  const lock = await waitForDataLock(1e3);
+  if (lock === null) {
+    logError("ingest", new Error("data lock timeout; ingest skipped this cycle"));
+    return emptyResult(false, fx, false);
+  }
+  try {
+    return await processFiles(claudeFiles, codexFiles, claudeRoots, table, fx, false);
+  } finally {
+    lock.release();
+  }
+}
+async function processFiles(claudeFiles, codexFiles, claudeRoots, table, fx, dryRun) {
+  const mtimeCache = loadIngestMtimeCache();
+  const nextMtimeCache = { ...mtimeCache };
+  const result = emptyResult(dryRun, fx, true);
+  const cursorsDict = loadAllCursors();
+  let cursorsChanged = false;
+  let index = null;
+  const historyIndex = () => index ??= loadHistoryIndex();
+  const recordedFloor = (scope, sessionId) => {
+    if (sessionId.length === 0) return null;
+    return historyIndex().legacyFloors.get(floorKey(scope, sessionId)) ?? null;
+  };
+  const countedFilter = () => messageKeyFilterOf(historyIndex().countedCalls);
+  const commit = (filePath, records, newCursor, subagentCursors = []) => {
+    const fresh = [];
+    for (const rec of records) {
+      const key = rec.ingestKey;
+      if (key !== void 0 && historyIndex().ingestKeys.has(key)) {
+        result.skippedDuplicates += 1;
+        continue;
+      }
+      if (key !== void 0) historyIndex().ingestKeys.add(key);
+      for (const fp of rec.countedCalls ?? []) historyIndex().countedCalls.add(fp);
+      fresh.push(rec);
+    }
+    if (!dryRun) {
+      for (const rec of fresh) appendTurn(rec);
+      cursorsDict[filePath] = newCursor;
+      for (const nc of subagentCursors) cursorsDict[nc.path] = nc.cursor;
+      cursorsChanged = true;
+    }
+    for (const rec of fresh) addRecord(result, rec);
+  };
+  const carryCursor = (next, prev, floor) => ({
+    ...next,
+    lastUuid: next.lastUuid ?? prev?.lastUuid ?? null,
+    lastTs: next.lastTs ?? prev?.lastTs ?? floor
+  });
+  const processClaudeFile = async (filePath) => {
+    const cursor = sanitizeCursor(cursorsDict[filePath]);
+    const counted = countedFilter();
+    let split = await splitIntoTurnDrafts(filePath, cursor, { excludeMessageKeys: counted });
+    if (split.unreadable === true) throw new Error(`transcript \u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093\u3067\u3057\u305F: ${filePath}`);
+    const sessionId = sessionIdOfDrafts(split.drafts) || sessionIdFromTranscriptPath(filePath);
+    let floor = null;
+    if (cursor === null) {
+      floor = recordedFloor("claude", sessionId);
+      if (floor !== null) {
+        split = await splitIntoTurnDrafts(filePath, recoveryCursor(floor), { excludeMessageKeys: counted });
+      }
+    }
+    const newCursor = carryCursor(split.newCursor, cursor, floor);
+    const surface = surfaceForClaudePath(filePath, claudeRoots);
+    const records = split.drafts.map(
+      (draft) => buildClaudeDraftRecord(draft, draft.lastTs ?? (/* @__PURE__ */ new Date()).toISOString(), table, fx, surface)
+    );
+    const saFloor = recordedFloor("claude-sa", sessionId);
+    let sa = null;
+    try {
+      sa = await collectSubagentUsage(filePath, {
+        excludeMessageKeys: anyOf([new Set(split.messageKeys), counted]),
+        recovery: () => ({ minTimestampMs: saFloor === null ? null : Date.parse(saFloor) + 1 }),
+        readCursor: (path) => sanitizeCursor(cursorsDict[path])
+      });
+    } catch (err) {
+      logError("ingest:subagents", err);
+      sa = null;
+    }
+    if (sa !== null && sa.apiCalls > 0) {
+      attachSubagentGroups(records, sa, table, fx, surface, "scan");
+    }
+    commit(filePath, records, newCursor, sa?.newCursors ?? []);
+  };
+  const processCodexFile = async (filePath) => {
+    const cursor = sanitizeCursor(cursorsDict[filePath]);
+    const scanOpts = { excludeEvents: historyIndex().countedCalls };
+    const scan = await scanCodexTurns(filePath, cursor, scanOpts);
+    if (scan === null) throw new Error(`rollout \u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093\u3067\u3057\u305F: ${filePath}`);
+    const drafts = scan.drafts;
+    if (drafts.length === 0) {
+      commit(filePath, [], scan.newCursor);
+      return;
+    }
+    const windowCursor = scan.newCursor;
+    if (drafts[0].isSubagentRollout) {
+      commit(filePath, [], windowCursor);
+      return;
+    }
+    if (cursor !== null) {
+      commit(filePath, drafts.map((draft) => buildCodexRecord(draft.agg, table, fx)), windowCursor);
+      return;
+    }
+    const floor = recordedFloor("codex", drafts[0].agg.sessionId);
+    const target = floor === null ? drafts : (await scanCodexTurns(filePath, await codexResumePointAtTs(filePath, floor), scanOpts))?.drafts ?? [];
+    commit(filePath, target.map((draft) => buildCodexRecord(draft.agg, table, fx)), windowCursor);
+  };
+  const runOver = async (files, context, handle, signature = fileMtimeMs) => {
+    for (const filePath of files) {
+      let mtimeMs;
+      try {
+        mtimeMs = await signature(filePath);
+      } catch (err) {
+        if (err?.code !== "ENOENT") {
+          result.failures += 1;
+          logError(context, err);
+        }
+        continue;
+      }
+      const cached = mtimeCache[filePath];
+      if (cached !== void 0 && cached >= mtimeMs && sanitizeCursor(cursorsDict[filePath]) !== null) {
+        result.skippedByMtime += 1;
+        continue;
+      }
+      result.scannedFiles += 1;
+      try {
+        await handle(filePath);
+        nextMtimeCache[filePath] = mtimeMs;
+      } catch (err) {
+        result.failures += 1;
+        logError(context, err);
+      }
+    }
+  };
+  await runOver(claudeFiles, "ingest:claude", processClaudeFile, claudeMtimeSignature);
+  await runOver(codexFiles, "ingest:codex", processCodexFile);
+  if (!dryRun) {
+    if (cursorsChanged) saveAllCursors(cursorsDict);
+    saveIngestMtimeCache(nextMtimeCache);
+  }
+  return result;
+}
+async function notifyIngestSummary(result, cfg) {
+  if (result.dryRun) return;
+  if (result.records.length === 0) return;
+  if (!(cfg.notify.os || cfg.notify.slack)) return;
+  if (result.totalUSD < cfg.minNotifyUSD) return;
+  if (isMuted()) return;
+  const bySurface = {};
+  for (const [surface, v] of Object.entries(result.bySurface)) {
+    if (v) bySurface[surface] = v;
+  }
+  const summary = formatIngestSummary(
+    { recordCount: result.records.length, totalUSD: result.totalUSD, totalJPY: result.totalJPY, bySurface },
+    cfg
+  );
+  const record = {
+    schemaVersion: 1,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: "ingest-scan",
+    project: "",
+    gitBranch: null,
+    models: [],
+    tokens: emptyBuckets(),
+    sidechainTokens: null,
+    apiCalls: 0,
+    costUSD: result.totalUSD,
+    costJPY: result.totalJPY,
+    fxRate: result.fxRate,
+    fxSource: result.fxSource,
+    prompt: ""
+  };
+  await Promise.allSettled([
+    notifyOS(record, cfg, void 0, summary),
+    notifySlack(record, cfg, void 0, summary)
+  ]);
+}
+
+export {
+  runIngest,
+  notifyIngestSummary
+};