@chigichan24/crune 0.1.0

package/dist-cli/__tests__/topic-nodes.test.js

@@ -0,0 +1,184 @@
+import { describe, it, expect } from "vitest";
+import { extractDominantAction, classifyDominantRole, computeToolSignature, } from "../knowledge-graph-builder.js";
+function makeSession(overrides = {}) {
+    return {
+        sessionId: "s1",
+        projectDisplayName: "test-project",
+        turns: [],
+        subagents: {},
+        meta: {
+            sessionId: "s1",
+            createdAt: "2025-01-01T00:00:00Z",
+            lastActiveAt: "2025-01-01T01:00:00Z",
+            durationMinutes: 60,
+            filesEdited: [],
+            gitBranch: "main",
+            toolBreakdown: {},
+            subagentCount: 0,
+        },
+        ...overrides,
+    };
+}
+function makeToolIdf(tools, idfWeights) {
+    const toolVocabIndex = new Map();
+    tools.forEach((t, i) => toolVocabIndex.set(t, i));
+    return {
+        toolVocabulary: tools,
+        toolVocabIndex,
+        toolIdfWeights: new Map(Object.entries(idfWeights)),
+        vectors: new Map(),
+    };
+}
+describe("extractDominantAction", () => {
+    it('returns "fix" when fix is the most common English verb', () => {
+        const prompts = ["fix the bug", "fix another bug"];
+        expect(extractDominantAction(prompts)).toBe("fix");
+    });
+    it('maps Japanese 修正 to "fix"', () => {
+        const prompts = ["修正してください", "修正お願い"];
+        expect(extractDominantAction(prompts)).toBe("fix");
+    });
+    it('returns "work on" when no recognized action verbs are found', () => {
+        const prompts = ["hello world"];
+        expect(extractDominantAction(prompts)).toBe("work on");
+    });
+    it("returns the most frequent verb when multiple are present", () => {
+        const prompts = [
+            "add a new feature",
+            "add another thing",
+            "add the component",
+            "fix the bug",
+        ];
+        expect(extractDominantAction(prompts)).toBe("add");
+    });
+});
+describe("classifyDominantRole", () => {
+    it('returns "subagent-delegated" when subagent ratio > 0.15', () => {
+        const session = makeSession({
+            turns: [
+                {
+                    userPrompt: "do something",
+                    assistantTexts: ["ok"],
+                    toolCalls: [
+                        { toolName: "Agent", input: {} },
+                        { toolName: "Agent", input: {} },
+                    ],
+                },
+            ],
+            subagents: {
+                "agent-1": {
+                    agentId: "agent-1",
+                    agentType: "code",
+                    turns: [],
+                },
+                "agent-2": {
+                    agentId: "agent-2",
+                    agentType: "code",
+                    turns: [],
+                },
+            },
+        });
+        expect(classifyDominantRole([session])).toBe("subagent-delegated");
+    });
+    it('returns "tool-heavy" when tool ratio > 0.6', () => {
+        const session = makeSession({
+            turns: [
+                {
+                    userPrompt: "run tools",
+                    assistantTexts: ["ok"],
+                    toolCalls: [
+                        { toolName: "Bash", input: {} },
+                        { toolName: "Read", input: {} },
+                        { toolName: "Grep", input: {} },
+                        { toolName: "Bash", input: {} },
+                        { toolName: "Edit", input: {} },
+                    ],
+                },
+            ],
+            subagents: {},
+        });
+        expect(classifyDominantRole([session])).toBe("tool-heavy");
+    });
+    it('returns "user-driven" when neither ratio is high', () => {
+        const sessions = [
+            makeSession({
+                turns: [
+                    { userPrompt: "prompt 1", assistantTexts: ["ok"], toolCalls: [] },
+                    { userPrompt: "prompt 2", assistantTexts: ["ok"], toolCalls: [] },
+                    {
+                        userPrompt: "prompt 3",
+                        assistantTexts: ["ok"],
+                        toolCalls: [{ toolName: "Read", input: {} }],
+                    },
+                ],
+                subagents: {},
+            }),
+        ];
+        expect(classifyDominantRole(sessions)).toBe("user-driven");
+    });
+});
+describe("computeToolSignature", () => {
+    it("returns sorted array with max 5 items, scored by log(1+count)*IDF", () => {
+        const session = makeSession({
+            meta: {
+                sessionId: "s1",
+                createdAt: "2025-01-01T00:00:00Z",
+                lastActiveAt: "2025-01-01T01:00:00Z",
+                durationMinutes: 60,
+                filesEdited: [],
+                gitBranch: "main",
+                toolBreakdown: {
+                    Bash: 50,
+                    Read: 30,
+                    Edit: 20,
+                    Grep: 10,
+                    Glob: 5,
+                    Write: 3,
+                    Agent: 1,
+                },
+                subagentCount: 0,
+            },
+        });
+        const toolIdf = makeToolIdf(["Bash", "Read", "Edit", "Grep", "Glob", "Write", "Agent"], {
+            Bash: 1.0,
+            Read: 1.5,
+            Edit: 2.0,
+            Grep: 1.8,
+            Glob: 2.5,
+            Write: 3.0,
+            Agent: 4.0,
+        });
+        const result = computeToolSignature([session], toolIdf);
+        // Max 5 items
+        expect(result.length).toBeLessThanOrEqual(5);
+        // Sorted descending by weight
+        for (let i = 1; i < result.length; i++) {
+            expect(result[i - 1].weight).toBeGreaterThanOrEqual(result[i].weight);
+        }
+        // Each entry has tool and weight
+        for (const entry of result) {
+            expect(entry).toHaveProperty("tool");
+            expect(entry).toHaveProperty("weight");
+            expect(typeof entry.tool).toBe("string");
+            expect(typeof entry.weight).toBe("number");
+            expect(entry.weight).toBeGreaterThan(0);
+        }
+    });
+    it("returns empty array when sessions have no tools", () => {
+        const session = makeSession({
+            meta: {
+                sessionId: "s1",
+                createdAt: "2025-01-01T00:00:00Z",
+                lastActiveAt: "2025-01-01T01:00:00Z",
+                durationMinutes: 60,
+                filesEdited: [],
+                gitBranch: "main",
+                toolBreakdown: {},
+                subagentCount: 0,
+            },
+        });
+        const toolIdf = makeToolIdf([], {});
+        const result = computeToolSignature([session], toolIdf);
+        expect(result).toEqual([]);
+    });
+});

package/dist-cli/analyze-sessions.js

@@ -0,0 +1,476 @@
+/**
+ * analyze-sessions.ts
+ *
+ * Data pipeline that reads Claude Code JSONL session logs and generates
+ * JSON files for the crune web UI.
+ *
+ * Usage:
+ *   npx tsx scripts/analyze-sessions.ts [--sessions-dir <path>] [--output-dir <path>]
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { buildSemanticKnowledgeGraph, } from "./knowledge-graph-builder.js";
+import { buildSynthesisPrompt, synthesizeWithClaude } from "./skill-synthesizer.js";
+import { generateSessionSummary } from "./session-summarizer.js";
+import { discoverSessions, parseJsonlFile, buildTurns, extractMetadata, parseSubagents, loadLinkedPlan, } from "./session-parser.js";
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let sessionsDir = path.join(os.homedir(), ".claude", "projects");
+    let outputDir = path.resolve("public", "data", "sessions");
+    let skipSynthesis = false;
+    let synthesisModel;
+    let synthesisCount = 5;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--sessions-dir" && args[i + 1]) {
+            sessionsDir = path.resolve(args[++i]);
+        }
+        else if (args[i] === "--output-dir" && args[i + 1]) {
+            outputDir = path.resolve(args[++i]);
+        }
+        else if (args[i] === "--skip-synthesis") {
+            skipSynthesis = true;
+        }
+        else if (args[i] === "--synthesis-model" && args[i + 1]) {
+            synthesisModel = args[++i];
+        }
+        else if (args[i] === "--synthesis-count" && args[i + 1]) {
+            synthesisCount = Math.max(1, parseInt(args[++i], 10) || 5);
+        }
+    }
+    return { sessionsDir, outputDir, skipSynthesis, synthesisModel, synthesisCount };
+}
+// ─── Task 1.5: index.json Generation ────────────────────────────────────────
+function generateIndex(sessions) {
+    const projectMap = new Map();
+    const sessionSummaries = sessions.map((s) => {
+        const existing = projectMap.get(s.projectDisplayName) || {
+            count: 0,
+            duration: 0,
+        };
+        projectMap.set(s.projectDisplayName, {
+            count: existing.count + 1,
+            duration: existing.duration + s.meta.durationMinutes,
+        });
+        const summaryInfo = generateSessionSummary(s.turns.map((t) => ({ userPrompt: t.userPrompt, permissionMode: s.meta.permissionMode })), {
+            toolBreakdown: s.meta.toolBreakdown,
+            filesEdited: s.meta.filesEdited,
+            permissionMode: s.meta.permissionMode,
+            turnCount: s.meta.turnCount,
+        });
+        return {
+            sessionId: s.meta.sessionId,
+            project: s.projectDisplayName,
+            cwd: s.meta.cwd,
+            gitBranch: s.meta.gitBranch,
+            slug: s.meta.slug,
+            createdAt: s.meta.createdAt,
+            lastActiveAt: s.meta.lastActiveAt,
+            durationMinutes: s.meta.durationMinutes,
+            turnCount: s.meta.turnCount,
+            toolBreakdown: s.meta.toolBreakdown,
+            firstUserPrompt: s.meta.firstUserPrompt,
+            summaryText: summaryInfo.summary,
+            keywords: summaryInfo.keywords,
+            scope: summaryInfo.scope,
+            workType: summaryInfo.workType,
+            permissionMode: s.meta.permissionMode,
+            subagentCount: s.meta.subagentCount,
+        };
+    });
+    // Sort sessions by createdAt descending
+    sessionSummaries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    const projects = [...projectMap.entries()].map(([name, data]) => ({
+        name,
+        sessionCount: data.count,
+        totalDurationMinutes: data.duration,
+    }));
+    projects.sort((a, b) => b.sessionCount - a.sessionCount);
+    return {
+        generatedAt: new Date().toISOString(),
+        totalSessions: sessions.length,
+        projects,
+        sessions: sessionSummaries,
+    };
+}
+// ─── Task 1.6: detail/{sessionId}.json Generation ───────────────────────────
+function generateDetail(session) {
+    return {
+        sessionId: session.meta.sessionId,
+        meta: {
+            project: session.projectDisplayName,
+            cwd: session.meta.cwd,
+            branch: session.meta.gitBranch,
+            slug: session.meta.slug,
+            version: session.meta.version,
+            createdAt: session.meta.createdAt,
+            lastActiveAt: session.meta.lastActiveAt,
+            durationMinutes: session.meta.durationMinutes,
+            permissionMode: session.meta.permissionMode,
+        },
+        turns: session.turns,
+        subagents: session.subagents,
+        linkedPlan: session.linkedPlan,
+    };
+}
+async function generateOverview(sessions, synthesisConfig = { skip: false, count: 5 }) {
+    // Activity heatmap: 7 days x 24 hours
+    const heatmap = Array.from({ length: 7 }, () => Array(24).fill(0));
+    // Project distribution
+    const projectMap = new Map();
+    // Weekly tool trends
+    const weeklyTools = new Map();
+    // Duration distribution buckets
+    const durationBuckets = {
+        "0-5min": 0,
+        "5-15min": 0,
+        "15-30min": 0,
+        "30-60min": 0,
+        "60-120min": 0,
+        "120min+": 0,
+    };
+    // File edit counts
+    const fileEditCounts = new Map();
+    // Model usage
+    const modelCounts = new Map();
+    // Knowledge graph (built separately via semantic pipeline)
+    // Tacit knowledge
+    const projectPlanMode = new Map();
+    const toolSequences = [];
+    const sessionFileEdits = new Map();
+    for (const session of sessions) {
+        const { meta } = session;
+        // Heatmap
+        if (meta.createdAt) {
+            const date = new Date(meta.createdAt);
+            const day = date.getDay(); // 0=Sun
+            const hour = date.getHours();
+            heatmap[day][hour]++;
+        }
+        // Project distribution
+        const projData = projectMap.get(session.projectDisplayName) || {
+            sessionCount: 0,
+            totalDurationMinutes: 0,
+        };
+        projData.sessionCount++;
+        projData.totalDurationMinutes += meta.durationMinutes;
+        projectMap.set(session.projectDisplayName, projData);
+        // Weekly tool trends
+        if (meta.createdAt) {
+            const weekLabel = getWeekLabel(new Date(meta.createdAt));
+            const weekTools = weeklyTools.get(weekLabel) || {};
+            for (const [tool, count] of Object.entries(meta.toolBreakdown)) {
+                weekTools[tool] = (weekTools[tool] || 0) + count;
+            }
+            weeklyTools.set(weekLabel, weekTools);
+        }
+        // Duration distribution
+        const dur = meta.durationMinutes;
+        if (dur < 5)
+            durationBuckets["0-5min"]++;
+        else if (dur < 15)
+            durationBuckets["5-15min"]++;
+        else if (dur < 30)
+            durationBuckets["15-30min"]++;
+        else if (dur < 60)
+            durationBuckets["30-60min"]++;
+        else if (dur < 120)
+            durationBuckets["60-120min"]++;
+        else
+            durationBuckets["120min+"]++;
+        // File edit counts
+        for (const file of meta.filesEdited) {
+            fileEditCounts.set(file, (fileEditCounts.get(file) || 0) + 1);
+        }
+        // Track per-session file edit counts for pain points
+        const sessionFileEditMap = new Map();
+        for (const turn of session.turns) {
+            for (const tc of turn.toolCalls) {
+                if (tc.toolName === "Edit" && typeof tc.input.file_path === "string") {
+                    const fp = tc.input.file_path;
+                    sessionFileEditMap.set(fp, (sessionFileEditMap.get(fp) || 0) + 1);
+                }
+            }
+        }
+        sessionFileEdits.set(meta.sessionId, sessionFileEditMap);
+        // Model usage
+        for (const [model, count] of Object.entries(meta.modelsUsed)) {
+            modelCounts.set(model, (modelCounts.get(model) || 0) + count);
+        }
+        // Tacit knowledge: plan mode usage
+        const projPlan = projectPlanMode.get(session.projectDisplayName) || {
+            planCount: 0,
+            totalCount: 0,
+        };
+        projPlan.totalCount++;
+        if (meta.permissionMode === "plan")
+            projPlan.planCount++;
+        projectPlanMode.set(session.projectDisplayName, projPlan);
+        // Tool sequences (3-grams)
+        const toolNames = session.turns.flatMap((t) => t.toolCalls.map((tc) => tc.toolName));
+        for (let i = 0; i <= toolNames.length - 3; i++) {
+            toolSequences.push(toolNames.slice(i, i + 3));
+        }
+    }
+    // Build semantic knowledge graph
+    const sessionInputs = sessions.map((s) => ({
+        sessionId: s.meta.sessionId,
+        projectDisplayName: s.projectDisplayName,
+        turns: s.turns.map((t) => ({
+            userPrompt: t.userPrompt,
+            assistantTexts: t.assistantTexts,
+            toolCalls: t.toolCalls.map((tc) => ({
+                toolName: tc.toolName,
+                input: tc.input,
+            })),
+        })),
+        subagents: Object.fromEntries(Object.entries(s.subagents).map(([id, sub]) => [
+            id,
+            {
+                agentId: sub.agentId,
+                agentType: sub.agentType,
+                turns: sub.turns.map((t) => ({
+                    userPrompt: t.userPrompt,
+                    assistantTexts: t.assistantTexts,
+                    toolCalls: t.toolCalls.map((tc) => ({
+                        toolName: tc.toolName,
+                        input: tc.input,
+                    })),
+                })),
+            },
+        ])),
+        meta: {
+            sessionId: s.meta.sessionId,
+            createdAt: s.meta.createdAt,
+            lastActiveAt: s.meta.lastActiveAt,
+            durationMinutes: s.meta.durationMinutes,
+            filesEdited: s.meta.filesEdited,
+            gitBranch: s.meta.gitBranch,
+            toolBreakdown: s.meta.toolBreakdown,
+            subagentCount: s.meta.subagentCount,
+        },
+    }));
+    const knowledgeGraph = buildSemanticKnowledgeGraph(sessionInputs);
+    // Top files
+    const topFiles = [...fileEditCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 50)
+        .map(([file, editCount]) => ({ file, editCount }));
+    // Model usage
+    const modelUsage = [...modelCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .map(([model, count]) => ({ model, count }));
+    // Weekly tool trends sorted by week
+    const weeklyToolTrends = [...weeklyTools.entries()]
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([week, tools]) => ({ week, tools }));
+    // Duration distribution
+    const durationDistribution = Object.entries(durationBuckets).map(([bucket, count]) => ({ bucket, count }));
+    // Project distribution
+    const projectDistribution = [...projectMap.entries()]
+        .sort((a, b) => b[1].sessionCount - a[1].sessionCount)
+        .map(([name, data]) => ({
+        name,
+        sessionCount: data.sessionCount,
+        totalDurationMinutes: data.totalDurationMinutes,
+    }));
+    // Tacit knowledge
+    const workflowPatterns = [...projectPlanMode.entries()].map(([project, data]) => ({
+        project,
+        planModeUsage: data.planCount,
+        totalSessions: data.totalCount,
+    }));
+    // Common tool 3-gram sequences
+    const seqCounts = new Map();
+    for (const seq of toolSequences) {
+        const key = seq.join(" -> ");
+        seqCounts.set(key, (seqCounts.get(key) || 0) + 1);
+    }
+    const commonToolSequences = [...seqCounts.entries()]
+        .filter(([, count]) => count >= 2)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 20)
+        .map(([key, count]) => ({
+        sequence: key.split(" -> "),
+        count,
+    }));
+    // Pain points
+    const durations = sessions.map((s) => s.meta.durationMinutes);
+    const sortedDurations = [...durations].sort((a, b) => a - b);
+    const medianDuration = sortedDurations.length > 0
+        ? sortedDurations[Math.floor(sortedDurations.length / 2)]
+        : 0;
+    const longSessions = sessions
+        .filter((s) => s.meta.durationMinutes > medianDuration * 2 && medianDuration > 0)
+        .map((s) => ({
+        sessionId: s.meta.sessionId,
+        durationMinutes: s.meta.durationMinutes,
+        medianDuration,
+    }));
+    const hotFiles = [];
+    for (const [sessionId, fileMap] of sessionFileEdits) {
+        for (const [file, count] of fileMap) {
+            if (count >= 5) {
+                hotFiles.push({ file, editCount: count, sessionId });
+            }
+        }
+    }
+    hotFiles.sort((a, b) => b.editCount - a.editCount);
+    // Pre-synthesize top skill candidates with claude -p
+    if (!synthesisConfig.skip) {
+        const topCandidates = [...knowledgeGraph.skillCandidates]
+            .sort((a, b) => b.reusabilityScore - a.reusabilityScore)
+            .slice(0, synthesisConfig.count);
+        const synthOpts = {};
+        if (synthesisConfig.model) {
+            synthOpts.model = synthesisConfig.model;
+        }
+        const total = topCandidates.length;
+        if (total > 0) {
+            console.error(`[crune] Synthesizing top ${total} skill candidates${synthesisConfig.model ? ` (model: ${synthesisConfig.model})` : ""}...`);
+        }
+        for (let i = 0; i < topCandidates.length; i++) {
+            const candidate = topCandidates[i];
+            const topic = knowledgeGraph.nodes.find((n) => n.id === candidate.topicId);
+            if (!topic)
+                continue;
+            const topicSessionSet = new Set(topic.sessionIds);
+            const relatedSequences = knowledgeGraph.enrichedToolSequences.filter((seq) => seq.sessionIds.some((sid) => topicSessionSet.has(sid)));
+            console.error(`[crune]   [${i + 1}/${total}] ${topic.label}...`);
+            const prompt = buildSynthesisPrompt({
+                skillCandidate: candidate,
+                topicNode: topic,
+                enrichedSequences: relatedSequences,
+            });
+            const result = await synthesizeWithClaude(prompt, synthOpts);
+            if (result.success) {
+                const original = knowledgeGraph.skillCandidates.find((sc) => sc.topicId === candidate.topicId);
+                if (original) {
+                    original.synthesizedMarkdown = result.stdout;
+                }
+                console.error(`[crune]   [${i + 1}/${total}] Done.`);
+            }
+            else {
+                console.error(`[crune]   [${i + 1}/${total}] Failed: ${result.error}`);
+            }
+        }
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        activityHeatmap: heatmap,
+        projectDistribution,
+        weeklyToolTrends,
+        durationDistribution,
+        topFiles,
+        modelUsage,
+        knowledgeGraph,
+        tacitKnowledge: {
+            workflowPatterns,
+            commonToolSequences,
+            enrichedToolSequences: knowledgeGraph.enrichedToolSequences ?? [],
+            skillCandidates: knowledgeGraph.skillCandidates ?? [],
+            painPoints: {
+                longSessions,
+                hotFiles: hotFiles.slice(0, 20),
+            },
+        },
+    };
+}
+function getWeekLabel(date) {
+    // ISO week label: "2026-W10"
+    const jan4 = new Date(date.getFullYear(), 0, 4);
+    const dayDiff = (date.getTime() - jan4.getTime()) / 86400000;
+    const weekNum = Math.ceil((dayDiff + jan4.getDay() + 1) / 7);
+    return `${date.getFullYear()}-W${String(weekNum).padStart(2, "0")}`;
+}
+// buildKnowledgeGraphEdges removed — replaced by buildSemanticKnowledgeGraph
+// ─── Main Pipeline ──────────────────────────────────────────────────────────
+async function main() {
+    const { sessionsDir, outputDir, skipSynthesis, synthesisModel, synthesisCount } = parseArgs();
+    console.error(`[crune] Sessions dir: ${sessionsDir}`);
+    console.error(`[crune] Output dir:   ${outputDir}`);
+    // Step 1: Discover sessions
+    console.error(`\n[crune] Discovering sessions...`);
+    const sessionFiles = discoverSessions(sessionsDir);
+    console.error(`[crune] Found ${sessionFiles.length} sessions`);
+    if (sessionFiles.length === 0) {
+        console.error("[crune] No sessions found. Exiting.");
+        process.exit(1);
+    }
+    // Step 2: Parse each session with metadata and subagents
+    const parsedSessions = [];
+    for (let i = 0; i < sessionFiles.length; i++) {
+        const sf = sessionFiles[i];
+        console.error(`[crune] Processing session ${i + 1}/${sessionFiles.length}: ${sf.sessionId}`);
+        try {
+            // Parse main JSONL
+            const lines = await parseJsonlFile(sf.filePath);
+            const turns = buildTurns(lines);
+            const meta = extractMetadata(sf, lines, turns);
+            // Update projectDisplayName from cwd if available
+            let displayName = sf.projectDisplayName;
+            if (meta.cwd) {
+                const cwdParts = meta.cwd.split(path.sep).filter(Boolean);
+                if (cwdParts.length >= 2) {
+                    displayName = cwdParts.slice(-2).join("/");
+                }
+            }
+            // Parse subagents
+            const subagents = await parseSubagents(sf.subagentFiles);
+            // Load linked plan
+            const linkedPlan = loadLinkedPlan(meta.slug);
+            parsedSessions.push({
+                meta,
+                turns,
+                subagents,
+                linkedPlan,
+                projectDir: sf.projectDir,
+                projectDisplayName: displayName,
+            });
+        }
+        catch (err) {
+            console.error(`  [ERROR] Failed to process ${sf.sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    console.error(`\n[crune] Successfully parsed ${parsedSessions.length}/${sessionFiles.length} sessions`);
+    // Step 3: Generate output files
+    console.error(`\n[crune] Generating output files...`);
+    // Ensure output directories exist
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.mkdirSync(path.join(outputDir, "detail"), { recursive: true });
+    // index.json
+    const indexData = generateIndex(parsedSessions);
+    const indexPath = path.join(outputDir, "index.json");
+    fs.writeFileSync(indexPath, JSON.stringify(indexData, null, 2));
+    const indexSize = fs.statSync(indexPath).size;
+    console.error(`[crune] Wrote ${indexPath} (${(indexSize / 1024).toFixed(1)} KB)`);
+    // detail/{sessionId}.json
+    let totalDetailSize = 0;
+    for (const session of parsedSessions) {
+        const detail = generateDetail(session);
+        const detailPath = path.join(outputDir, "detail", `${session.meta.sessionId}.json`);
+        fs.writeFileSync(detailPath, JSON.stringify(detail, null, 2));
+        totalDetailSize += fs.statSync(detailPath).size;
+    }
+    console.error(`[crune] Wrote ${parsedSessions.length} detail files (${(totalDetailSize / 1024).toFixed(1)} KB total)`);
+    // overview.json
+    const overviewData = await generateOverview(parsedSessions, {
+        skip: skipSynthesis,
+        model: synthesisModel,
+        count: synthesisCount,
+    });
+    const overviewPath = path.join(outputDir, "overview.json");
+    fs.writeFileSync(overviewPath, JSON.stringify(overviewData, null, 2));
+    const overviewSize = fs.statSync(overviewPath).size;
+    console.error(`[crune] Wrote ${overviewPath} (${(overviewSize / 1024).toFixed(1)} KB)`);
+    // Summary
+    console.error(`\n[crune] --- Summary ---`);
+    console.error(`[crune] Total sessions:  ${parsedSessions.length}`);
+    console.error(`[crune] Total projects:  ${indexData.projects.length}`);
+    console.error(`[crune] Output size:     ${((indexSize + totalDetailSize + overviewSize) / 1024).toFixed(1)} KB`);
+    console.error(`[crune] Done.`);
+}
+main().catch((err) => {
+    console.error(`[crune] Fatal error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+});