ccc-notifier 0.1.0

package/dist/dashboard-LKK6NOBN.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import {
+  browserOpenPlan,
+  runDashboard,
+  writeDashboardHtml
+} from "./chunk-64N5SGTT.js";
+import "./chunk-DGXUSPS4.js";
+import "./chunk-TBFKGFZX.js";
+import "./chunk-IIYMGLV4.js";
+export {
+  browserOpenPlan,
+  runDashboard,
+  writeDashboardHtml
+};

package/dist/history-MWFHO5VR.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import {
+  paths
+} from "./chunk-IIYMGLV4.js";
+
+// src/history.ts
+import { existsSync, readFileSync, writeFileSync, renameSync, rmSync } from "fs";
+import * as p from "@clack/prompts";
+function parseFlags(argv) {
+  let days = null;
+  let yes = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--yes" || a === "-y") {
+      yes = true;
+    } else if (a === "--days") {
+      const n = Number.parseInt(argv[i + 1] ?? "", 10);
+      if (Number.isFinite(n) && n > 0) days = n;
+      i++;
+    } else if (a.startsWith("--days=")) {
+      const n = Number.parseInt(a.slice("--days=".length), 10);
+      if (Number.isFinite(n) && n > 0) days = n;
+    }
+  }
+  return { days, yes };
+}
+function readLines(file) {
+  const raw = readFileSync(file, "utf8");
+  const lines = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let rec = null;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      rec = null;
+    }
+    lines.push({ raw: line, rec });
+  }
+  return lines;
+}
+function isTargeted(rec, cutoffMs) {
+  if (cutoffMs === null) return true;
+  const ts = Date.parse(rec.ts);
+  if (!Number.isFinite(ts)) return false;
+  return ts < cutoffMs;
+}
+function atomicWrite(file, content) {
+  const tmp = `${file}.tmp`;
+  writeFileSync(tmp, content, "utf8");
+  renameSync(tmp, file);
+}
+async function runHistory(argv) {
+  const [sub, ...rest] = argv;
+  if (sub !== "clear" && sub !== "redact") {
+    console.error(
+      "\u4F7F\u3044\u65B9 / Usage: ccc-notifier history <clear|redact> [--days N] [--yes]\n  clear  \u2026 \u30EC\u30B3\u30FC\u30C9\u3054\u3068\u524A\u9664(\u30C1\u30E3\u30FC\u30C8\u30FB\u96C6\u8A08\u304B\u3089\u3082\u6D88\u3048\u308B) / delete records\n  redact \u2026 \u30D7\u30ED\u30F3\u30D7\u30C8\u5168\u6587\u3060\u3051\u6D88\u3059(\u30B3\u30B9\u30C8\u30FB\u30C1\u30E3\u30FC\u30C8\u306F\u6B8B\u3059) / strip prompts only"
+    );
+    return 1;
+  }
+  const flags = parseFlags(rest);
+  const file = paths().historyFile;
+  if (!existsSync(file)) {
+    console.log("\u5C65\u6B74\u304C\u3042\u308A\u307E\u305B\u3093(history.jsonl \u306F\u672A\u4F5C\u6210\u3067\u3059)\u3002");
+    return 0;
+  }
+  const lines = readLines(file);
+  const cutoff = flags.days !== null ? Date.now() - flags.days * 864e5 : null;
+  const scope = flags.days !== null ? `${flags.days}\u65E5\u3088\u308A\u524D` : "\u5168\u671F\u9593";
+  const targetSet = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    const rec = lines[i].rec;
+    if (!rec || !isTargeted(rec, cutoff)) continue;
+    if (sub === "redact" && !(typeof rec.prompt === "string" && rec.prompt.length > 0)) continue;
+    targetSet.add(i);
+  }
+  if (targetSet.size === 0) {
+    console.log(`\u5BFE\u8C61\u304C\u3042\u308A\u307E\u305B\u3093(${scope})\u3002`);
+    return 0;
+  }
+  const action = sub === "clear" ? "\u30EC\u30B3\u30FC\u30C9\u3054\u3068\u524A\u9664" : "\u30D7\u30ED\u30F3\u30D7\u30C8\u5168\u6587\u3092\u6D88\u53BB";
+  if (!flags.yes) {
+    const confirmed = await p.confirm({
+      message: `${scope}\u306E\u5C65\u6B74 ${targetSet.size} \u4EF6\u3092${action}\u3057\u307E\u3059\u3002\u5143\u306B\u623B\u305B\u307E\u305B\u3093\u3002\u3088\u308D\u3057\u3044\u3067\u3059\u304B?`,
+      initialValue: false
+    });
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.cancel("\u30AD\u30E3\u30F3\u30BB\u30EB\u3057\u307E\u3057\u305F");
+      return 0;
+    }
+  }
+  if (sub === "clear") {
+    const kept = lines.filter((_, i) => !targetSet.has(i)).map((l) => l.raw);
+    if (kept.length === 0) {
+      rmSync(file, { force: true });
+    } else {
+      atomicWrite(file, kept.join("\n") + "\n");
+    }
+    console.log(`\u5C65\u6B74 ${targetSet.size} \u4EF6\u3092\u524A\u9664\u3057\u307E\u3057\u305F(${scope})\u3002`);
+  } else {
+    const out = lines.map((l, i) => {
+      if (!targetSet.has(i) || l.rec === null) return l.raw;
+      return JSON.stringify({ ...l.rec, prompt: "" });
+    });
+    atomicWrite(file, out.join("\n") + "\n");
+    console.log(
+      `\u30D7\u30ED\u30F3\u30D7\u30C8\u5168\u6587\u3092 ${targetSet.size} \u4EF6\u6D88\u53BB\u3057\u307E\u3057\u305F(${scope}\u3002\u30B3\u30B9\u30C8\u96C6\u8A08\u30FB\u30C1\u30E3\u30FC\u30C8\u306F\u4FDD\u6301\u3055\u308C\u307E\u3059)\u3002`
+    );
+  }
+  return 0;
+}
+export {
+  runHistory
+};

package/dist/mute-2JW3NQXN.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  fmtMuteUntil,
+  runMute,
+  runUnmute
+} from "./chunk-KUJZYZSG.js";
+import "./chunk-IIYMGLV4.js";
+export {
+  fmtMuteUntil,
+  runMute,
+  runUnmute
+};

package/dist/setup-RT62VO37.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {
+  matchesMarker,
+  runInit,
+  runUninstall
+} from "./chunk-L5MLVTA2.js";
+import "./chunk-4JNZ7BHO.js";
+import "./chunk-DGXUSPS4.js";
+import "./chunk-TBFKGFZX.js";
+import "./chunk-IIYMGLV4.js";
+export {
+  matchesMarker,
+  runInit,
+  runUninstall
+};

package/dist/sweep-XKKODGMA.js

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+import {
+  collectSubagentUsage
+} from "./chunk-TB5A7U7G.js";
+import {
+  computeCost,
+  extractBucket,
+  getUsdJpy,
+  loadPriceTable,
+  promptCandidate
+} from "./chunk-OEG3AVU6.js";
+import {
+  formatJPY,
+  formatUSD,
+  modelDisplayName
+} from "./chunk-TBFKGFZX.js";
+import {
+  appendTurn,
+  loadCursor,
+  logError,
+  paths,
+  readConfig,
+  sanitizeCursor,
+  saveCursor
+} from "./chunk-IIYMGLV4.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 ACTIVE_GUARD_MIN = 5;
+var ACTIVE_GUARD_MS = ACTIVE_GUARD_MIN * 6e4;
+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 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 };
+  }
+  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 };
+}
+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 maxCursorTs(newCursors) {
+  let max = null;
+  for (const nc of newCursors) {
+    const t = nc.cursor.lastTs;
+    if (t !== null && (max === null || t > max)) max = t;
+  }
+  return max;
+}
+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 processTranscript(mainPath, table, fx, daysCutoff, dryRun, summary) {
+  const cursor = sanitizeCursor(loadCursor(mainPath));
+  const { drafts, newCursor } = 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);
+  } catch (err) {
+    logError("sweep:subagents", err);
+    sa = null;
+  }
+  const saHasUsage = sa !== null && sa.apiCalls > 0;
+  if (saHasUsage) {
+    const saBreakdown = computeCost(sa.perModel, {}, table);
+    summary.subagentsUSD += saBreakdown.usd;
+    const saBlock = {
+      costUSD: saBreakdown.usd,
+      costByModel: saBreakdown.byModel,
+      tokens: sumBuckets(sa.perModel),
+      apiCalls: sa.apiCalls,
+      agentFiles: sa.agentFiles
+    };
+    if (records.length > 0) {
+      const last = records[records.length - 1];
+      last.subagents = saBlock;
+      mergeUnknownModels(last, saBreakdown.unknownModels);
+    } else {
+      const rec = {
+        schemaVersion: 1,
+        ts: maxCursorTs(sa.newCursors) ?? (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: "",
+        project: "",
+        gitBranch: null,
+        models: collectModels(sa.perModel, {}),
+        tokens: emptyBuckets(),
+        sidechainTokens: null,
+        apiCalls: 0,
+        costUSD: 0,
+        costByModel: {},
+        costJPY: 0,
+        fxRate: fx.rate,
+        fxSource: fx.source,
+        prompt: "",
+        subagents: saBlock,
+        ingest: "sweep"
+      };
+      mergeUnknownModels(rec, saBreakdown.unknownModels);
+      records.push(rec);
+    }
+    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 (saHasUsage) {
+      for (const nc of sa.newCursors) saveCursor(nc.path, nc.cursor);
+    }
+  }
+}
+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, includeActive: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--dry-run") {
+      flags.dryRun = true;
+    } else if (a === "--include-active") {
+      flags.includeActive = true;
+    } else if (a === "--days" || a.startsWith("--days=")) {
+      const v = a.includes("=") ? a.slice("--days=".length) : argv[++i];
+      const n = Number(v);
+      if (Number.isFinite(n) && n >= 0) flags.days = n;
+    } else if (a === "--projects" || a.startsWith("--projects=")) {
+      const v = a.includes("=") ? a.slice("--projects=".length) : argv[++i];
+      if (v) flags.projects = v;
+    }
+  }
+  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 isRecentlyModified(path) {
+  try {
+    const st = await fsp.stat(path);
+    return Date.now() - st.mtimeMs < ACTIVE_GUARD_MS;
+  } catch {
+    return false;
+  }
+}
+async function listTranscripts(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 [];
+  }
+}
+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.skippedActive > 0) {
+    console.log(
+      `\u30B9\u30AD\u30C3\u30D7: ${summary.skippedActive} transcript(\u76F4\u8FD1${ACTIVE_GUARD_MIN}\u5206\u4EE5\u5185\u306B\u66F4\u65B0 = \u9032\u884C\u4E2D\u30BB\u30C3\u30B7\u30E7\u30F3\u306E\u53EF\u80FD\u6027)\u3002\u30BB\u30C3\u30B7\u30E7\u30F3\u5B8C\u4E86\u5F8C\u306B\u518D\u5B9F\u884C\u3059\u308B\u304B\u3001\u5B8C\u4E86\u6E08\u307F\u3068\u5206\u304B\u3063\u3066\u3044\u308B\u5834\u5408\u306F --include-active \u3067\u53D6\u308A\u8FBC\u3081\u307E\u3059`
+    );
+  }
+  if (summary.newRecords === 0) {
+    console.log("\u65B0\u898F\u306F\u3042\u308A\u307E\u305B\u3093\u3067\u3057\u305F");
+  } else {
+    console.log(
+      `\u65B0\u898F\u53D6\u308A\u8FBC\u307F: ${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)})`
+      );
+    }
+    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("\u65E2\u306B\u8A08\u4E0A\u6E08\u307F\u306E\u5206\u306F\u30B9\u30AD\u30C3\u30D7\u3055\u308C\u307E\u3057\u305F(\u4E8C\u91CD\u8A08\u4E0A\u306A\u3057)");
+  console.log(`\u5186\u63DB\u7B97\u30EC\u30FC\u30C8: 1USD = ${fx.rate}JPY(source=${fx.source})`);
+}
+async function runSweep(argv) {
+  const flags = parseSweepFlags(argv);
+  const root = projectsRoot(flags.projects);
+  const projectDirs = await listProjectDirs(root);
+  if (projectDirs === null) {
+    console.log(`\u8D70\u67FB\u30EB\u30FC\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${root}`);
+    return 1;
+  }
+  const cfg = readConfig();
+  const cacheDir = paths().cacheDir;
+  const table = await loadPriceTable(cacheDir, { offline: false });
+  const fx = await getUsdJpy(cfg, cacheDir);
+  const summary = {
+    projects: projectDirs.length,
+    transcripts: 0,
+    agentFiles: 0,
+    newRecords: 0,
+    totalUSD: 0,
+    totalJPY: 0,
+    subagentsUSD: 0,
+    byModel: {},
+    skippedActive: 0,
+    dryRun: flags.dryRun
+  };
+  const daysCutoff = flags.days !== null ? Date.now() - flags.days * DAY_MS : null;
+  for (const projectDir of projectDirs) {
+    const transcripts = await listTranscripts(projectDir);
+    for (const mainPath of transcripts) {
+      summary.transcripts += 1;
+      if (!flags.includeActive && await isRecentlyModified(mainPath)) {
+        summary.skippedActive += 1;
+        continue;
+      }
+      try {
+        await processTranscript(mainPath, table, fx, daysCutoff, flags.dryRun, summary);
+      } catch (err) {
+        logError("sweep:transcript", err);
+      }
+    }
+  }
+  summary.totalJPY = summary.totalUSD * fx.rate;
+  printSweepSummary(summary, fx);
+  return 0;
+}
+export {
+  runSweep,
+  splitIntoTurnDrafts
+};