@chigichan24/crune 0.1.0

package/dist-cli/__tests__/orchestrator.test.js

@@ -0,0 +1,253 @@
+import { describe, it, expect } from "vitest";
+import { buildSemanticKnowledgeGraph } from "../knowledge-graph-builder.js";
+import { editHeavySession, readHeavySession, subagentSession, japaneseSession, makeSession, } from "./fixtures.js";
+describe("buildSemanticKnowledgeGraph", () => {
+    it("returns empty graph for empty sessions array", () => {
+        const result = buildSemanticKnowledgeGraph([]);
+        expect(result).toEqual({
+            nodes: [],
+            edges: [],
+            communities: [],
+            metrics: {
+                totalTopics: 0,
+                totalEdges: 0,
+                graphDensity: 0,
+                modularity: 0,
+                isolatedTopicCount: 0,
+                bridgeTopicIds: [],
+            },
+            enrichedToolSequences: [],
+            skillCandidates: [],
+        });
+    });
+    it("returns 1 topic and 0 edges for a single session", () => {
+        const result = buildSemanticKnowledgeGraph([editHeavySession]);
+        expect(result.nodes).toHaveLength(1);
+        expect(result.edges).toHaveLength(0);
+        expect(result.communities).toHaveLength(1);
+        expect(result.metrics.totalTopics).toBe(1);
+        expect(result.metrics.totalEdges).toBe(0);
+    });
+    it("produces >= 1 topic with correct structure for 5+ varied sessions", () => {
+        const sessions = [
+            editHeavySession,
+            readHeavySession,
+            subagentSession,
+            japaneseSession,
+            makeSession({
+                sessionId: "deploy-session",
+                projectDisplayName: "crune",
+                turns: [
+                    {
+                        userPrompt: "Deploy the application to production server",
+                        assistantTexts: ["Deploying to production"],
+                        toolCalls: [
+                            { toolName: "Bash", input: { command: "npm run build" } },
+                        ],
+                    },
+                ],
+                meta: {
+                    sessionId: "deploy-session",
+                    createdAt: "2025-01-04T10:00:00Z",
+                    lastActiveAt: "2025-01-04T10:30:00Z",
+                    durationMinutes: 30,
+                    filesEdited: ["/deploy/config.ts"],
+                    gitBranch: "deploy",
+                    toolBreakdown: { Bash: 3 },
+                    subagentCount: 0,
+                },
+            }),
+            makeSession({
+                sessionId: "testing-session",
+                projectDisplayName: "crune",
+                turns: [
+                    {
+                        userPrompt: "Write unit tests for the authentication module with jest",
+                        assistantTexts: [
+                            "I will create comprehensive test suites for the auth module",
+                        ],
+                        toolCalls: [
+                            {
+                                toolName: "Write",
+                                input: { file_path: "/src/__tests__/auth.test.ts", content: "test code" },
+                            },
+                            {
+                                toolName: "Bash",
+                                input: { command: "npx jest --coverage" },
+                            },
+                        ],
+                    },
+                    {
+                        userPrompt: "Add integration tests for the login flow",
+                        assistantTexts: [
+                            "Adding integration tests for the login endpoint",
+                        ],
+                        toolCalls: [
+                            {
+                                toolName: "Write",
+                                input: {
+                                    file_path: "/src/__tests__/login.integration.test.ts",
+                                    content: "integration test code",
+                                },
+                            },
+                        ],
+                    },
+                ],
+                meta: {
+                    sessionId: "testing-session",
+                    createdAt: "2025-01-05T14:00:00Z",
+                    lastActiveAt: "2025-01-05T15:00:00Z",
+                    durationMinutes: 60,
+                    filesEdited: [
+                        "/src/__tests__/auth.test.ts",
+                        "/src/__tests__/login.integration.test.ts",
+                    ],
+                    gitBranch: "feature/auth-tests",
+                    toolBreakdown: { Write: 2, Bash: 1 },
+                    subagentCount: 0,
+                },
+            }),
+            makeSession({
+                sessionId: "refactor-session",
+                projectDisplayName: "other-project",
+                turns: [
+                    {
+                        userPrompt: "Refactor the database layer to use connection pooling",
+                        assistantTexts: [
+                            "Refactoring database connections to use a pool",
+                        ],
+                        toolCalls: [
+                            {
+                                toolName: "Edit",
+                                input: {
+                                    file_path: "/src/db/connection.ts",
+                                    old_string: "createConnection",
+                                    new_string: "createPool",
+                                },
+                            },
+                            {
+                                toolName: "Read",
+                                input: { file_path: "/src/db/queries.ts" },
+                            },
+                        ],
+                    },
+                ],
+                meta: {
+                    sessionId: "refactor-session",
+                    createdAt: "2025-01-06T09:00:00Z",
+                    lastActiveAt: "2025-01-06T10:00:00Z",
+                    durationMinutes: 60,
+                    filesEdited: ["/src/db/connection.ts", "/src/db/queries.ts"],
+                    gitBranch: "refactor/db-pool",
+                    toolBreakdown: { Edit: 1, Read: 1 },
+                    subagentCount: 0,
+                },
+            }),
+        ];
+        const result = buildSemanticKnowledgeGraph(sessions);
+        // Should produce at least 1 topic
+        expect(result.nodes.length).toBeGreaterThanOrEqual(1);
+        // Verify top-level structure
+        expect(result).toHaveProperty("nodes");
+        expect(result).toHaveProperty("edges");
+        expect(result).toHaveProperty("communities");
+        expect(result).toHaveProperty("metrics");
+        expect(Array.isArray(result.nodes)).toBe(true);
+        expect(Array.isArray(result.edges)).toBe(true);
+        expect(Array.isArray(result.communities)).toBe(true);
+        // Verify metrics structure
+        expect(result.metrics).toHaveProperty("totalTopics");
+        expect(result.metrics).toHaveProperty("totalEdges");
+        expect(result.metrics).toHaveProperty("graphDensity");
+        expect(result.metrics).toHaveProperty("modularity");
+        expect(result.metrics).toHaveProperty("isolatedTopicCount");
+        expect(result.metrics).toHaveProperty("bridgeTopicIds");
+        expect(typeof result.metrics.totalTopics).toBe("number");
+        expect(typeof result.metrics.totalEdges).toBe("number");
+        expect(typeof result.metrics.graphDensity).toBe("number");
+        expect(typeof result.metrics.modularity).toBe("number");
+        expect(typeof result.metrics.isolatedTopicCount).toBe("number");
+        expect(Array.isArray(result.metrics.bridgeTopicIds)).toBe(true);
+        // Metrics should be consistent with nodes/edges
+        expect(result.metrics.totalTopics).toBe(result.nodes.length);
+        expect(result.metrics.totalEdges).toBe(result.edges.length);
+    });
+    it("nodes and edges have all required fields", () => {
+        const sessions = [
+            editHeavySession,
+            readHeavySession,
+            subagentSession,
+            japaneseSession,
+            makeSession({
+                sessionId: "deploy-session",
+                projectDisplayName: "crune",
+                turns: [
+                    {
+                        userPrompt: "Deploy the application to production server",
+                        assistantTexts: ["Deploying to production"],
+                        toolCalls: [
+                            { toolName: "Bash", input: { command: "npm run build" } },
+                        ],
+                    },
+                ],
+                meta: {
+                    sessionId: "deploy-session",
+                    createdAt: "2025-01-04T10:00:00Z",
+                    lastActiveAt: "2025-01-04T10:30:00Z",
+                    durationMinutes: 30,
+                    filesEdited: ["/deploy/config.ts"],
+                    gitBranch: "deploy",
+                    toolBreakdown: { Bash: 3 },
+                    subagentCount: 0,
+                },
+            }),
+        ];
+        const result = buildSemanticKnowledgeGraph(sessions);
+        // Validate node fields
+        for (const node of result.nodes) {
+            expect(node).toHaveProperty("id");
+            expect(node).toHaveProperty("label");
+            expect(node).toHaveProperty("keywords");
+            expect(node).toHaveProperty("project");
+            expect(node).toHaveProperty("projects");
+            expect(node).toHaveProperty("sessionIds");
+            expect(node).toHaveProperty("sessionCount");
+            expect(node).toHaveProperty("totalDurationMinutes");
+            expect(node).toHaveProperty("totalToolCalls");
+            expect(node).toHaveProperty("firstSeen");
+            expect(node).toHaveProperty("lastSeen");
+            expect(node).toHaveProperty("betweennessCentrality");
+            expect(node).toHaveProperty("degreeCentrality");
+            expect(node).toHaveProperty("communityId");
+            expect(node).toHaveProperty("representativePrompts");
+            expect(node).toHaveProperty("suggestedPrompt");
+            expect(node).toHaveProperty("toolSignature");
+            expect(node).toHaveProperty("dominantRole");
+            expect(typeof node.id).toBe("string");
+            expect(typeof node.label).toBe("string");
+            expect(Array.isArray(node.keywords)).toBe(true);
+            expect(Array.isArray(node.sessionIds)).toBe(true);
+            expect(typeof node.sessionCount).toBe("number");
+            expect(typeof node.betweennessCentrality).toBe("number");
+            expect(typeof node.degreeCentrality).toBe("number");
+            expect(typeof node.communityId).toBe("number");
+        }
+        // Validate edge fields (if any edges exist)
+        for (const edge of result.edges) {
+            expect(edge).toHaveProperty("source");
+            expect(edge).toHaveProperty("target");
+            expect(edge).toHaveProperty("type");
+            expect(edge).toHaveProperty("strength");
+            expect(edge).toHaveProperty("label");
+            expect(edge).toHaveProperty("signals");
+            expect(typeof edge.source).toBe("string");
+            expect(typeof edge.target).toBe("string");
+            expect(typeof edge.type).toBe("string");
+            expect(typeof edge.strength).toBe("number");
+            expect(typeof edge.label).toBe("string");
+            expect(edge.signals).toHaveProperty("semanticSimilarity");
+            expect(edge.signals).toHaveProperty("fileOverlap");
+            expect(edge.signals).toHaveProperty("sessionOverlap");
+        }
+    });
+});

package/dist-cli/__tests__/session-parser.test.js

@@ -0,0 +1,335 @@
+import { describe, it, expect } from "vitest";
+import { inferProjectName, truncate, isRealUserMessage, isToolResultMessage, extractUserPrompt, buildTurns, extractMetadata, } from "../session-parser.js";
+describe("inferProjectName", () => {
+    it("extracts org/repo from github-com pattern", () => {
+        expect(inferProjectName("-Users-kazuki-chigita-src-github-com-chigichan24-crune")).toBe("chigichan24/crune");
+    });
+    it("extracts org/repo from another github-com path", () => {
+        expect(inferProjectName("-Users-foo-github-com-org-repo")).toBe("org/repo");
+    });
+    it("falls back to last 2 segments when no github-com pattern", () => {
+        expect(inferProjectName("-Users-foo-bar-projects-myapp")).toBe("projects/myapp");
+    });
+    it("returns dirName as-is for single segment", () => {
+        expect(inferProjectName("short")).toBe("short");
+    });
+    it("returns empty string for empty input", () => {
+        expect(inferProjectName("")).toBe("");
+    });
+});
+describe("truncate", () => {
+    it("returns unchanged text shorter than limit", () => {
+        expect(truncate("hello", 10)).toBe("hello");
+    });
+    it("returns unchanged text exactly at limit", () => {
+        expect(truncate("12345", 5)).toBe("12345");
+    });
+    it("truncates text longer than limit with ellipsis", () => {
+        const result = truncate("hello world", 5);
+        expect(result).toBe("hello\u2026");
+        expect(result.length).toBe(6);
+    });
+    it("returns empty string for empty input", () => {
+        expect(truncate("", 10)).toBe("");
+    });
+});
+describe("isRealUserMessage", () => {
+    it("returns true for plain user message with string content", () => {
+        const line = { type: "user", message: { content: "hello" } };
+        expect(isRealUserMessage(line)).toBe(true);
+    });
+    it("returns false when isMeta is true", () => {
+        const line = { type: "user", isMeta: true, message: { content: "hello" } };
+        expect(isRealUserMessage(line)).toBe(false);
+    });
+    it("returns false when content contains command-name tag", () => {
+        const line = { type: "user", message: { content: "<command-name>foo</command-name>" } };
+        expect(isRealUserMessage(line)).toBe(false);
+    });
+    it("returns false for empty/whitespace content", () => {
+        const line = { type: "user", message: { content: "" } };
+        expect(isRealUserMessage(line)).toBe(false);
+    });
+    it("returns false for assistant type", () => {
+        const line = { type: "assistant", message: { content: "hello" } };
+        expect(isRealUserMessage(line)).toBe(false);
+    });
+    it("returns false when content is array with tool_result", () => {
+        const line = {
+            type: "user",
+            message: { content: [{ type: "tool_result", tool_use_id: "x", content: "result" }] },
+        };
+        expect(isRealUserMessage(line)).toBe(false);
+    });
+    it("returns true when content is array with text blocks", () => {
+        const line = {
+            type: "user",
+            message: { content: [{ type: "text", text: "hello" }] },
+        };
+        expect(isRealUserMessage(line)).toBe(true);
+    });
+});
+describe("isToolResultMessage", () => {
+    it("returns true for user message with tool_result content", () => {
+        const line = {
+            type: "user",
+            message: { content: [{ type: "tool_result", tool_use_id: "x" }] },
+        };
+        expect(isToolResultMessage(line)).toBe(true);
+    });
+    it("returns false for user message with string content", () => {
+        const line = { type: "user", message: { content: "hello" } };
+        expect(isToolResultMessage(line)).toBe(false);
+    });
+    it("returns false for assistant message with tool_result content", () => {
+        const line = {
+            type: "assistant",
+            message: { content: [{ type: "tool_result" }] },
+        };
+        expect(isToolResultMessage(line)).toBe(false);
+    });
+});
+describe("extractUserPrompt", () => {
+    it("returns string content directly", () => {
+        const line = { type: "user", message: { content: "hello world" } };
+        expect(extractUserPrompt(line)).toBe("hello world");
+    });
+    it("joins text blocks from array content", () => {
+        const line = {
+            type: "user",
+            message: { content: [{ type: "text", text: "first" }, { type: "text", text: "second" }] },
+        };
+        expect(extractUserPrompt(line)).toBe("first\nsecond");
+    });
+    it("returns empty string for array with no text blocks", () => {
+        const line = {
+            type: "user",
+            message: { content: [{ type: "tool_result", tool_use_id: "x" }] },
+        };
+        expect(extractUserPrompt(line)).toBe("");
+    });
+    it("returns empty string when no content", () => {
+        const line = { type: "user", message: {} };
+        expect(extractUserPrompt(line)).toBe("");
+    });
+});
+describe("buildTurns", () => {
+    it("returns empty array for empty input", () => {
+        expect(buildTurns([])).toEqual([]);
+    });
+    it("creates 1 turn from single user + assistant", () => {
+        const lines = [
+            { type: "user", timestamp: "2026-01-01T00:00:00Z", message: { content: "hello" } },
+            { type: "assistant", message: { content: [{ type: "text", text: "hi there" }], model: "claude-sonnet" } },
+        ];
+        const turns = buildTurns(lines);
+        expect(turns).toHaveLength(1);
+        expect(turns[0].turnIndex).toBe(0);
+        expect(turns[0].userPrompt).toBe("hello");
+        expect(turns[0].timestamp).toBe("2026-01-01T00:00:00Z");
+        expect(turns[0].assistantTexts).toEqual(["hi there"]);
+        expect(turns[0].model).toBe("claude-sonnet");
+    });
+    it("creates multiple turns with correct turnIndex", () => {
+        const lines = [
+            { type: "user", timestamp: "2026-01-01T00:00:00Z", message: { content: "first" } },
+            { type: "assistant", message: { content: [{ type: "text", text: "reply1" }] } },
+            { type: "user", timestamp: "2026-01-01T00:01:00Z", message: { content: "second" } },
+            { type: "assistant", message: { content: [{ type: "text", text: "reply2" }] } },
+        ];
+        const turns = buildTurns(lines);
+        expect(turns).toHaveLength(2);
+        expect(turns[0].turnIndex).toBe(0);
+        expect(turns[0].userPrompt).toBe("first");
+        expect(turns[1].turnIndex).toBe(1);
+        expect(turns[1].userPrompt).toBe("second");
+    });
+    it("populates toolCalls from tool_use blocks", () => {
+        const lines = [
+            { type: "user", timestamp: "2026-01-01T00:00:00Z", message: { content: "do something" } },
+            {
+                type: "assistant",
+                message: {
+                    content: [
+                        { type: "tool_use", id: "tu1", name: "Read", input: { file_path: "/tmp/test.ts" } },
+                    ],
+                },
+            },
+        ];
+        const turns = buildTurns(lines);
+        expect(turns[0].toolCalls).toHaveLength(1);
+        expect(turns[0].toolCalls[0].toolUseId).toBe("tu1");
+        expect(turns[0].toolCalls[0].toolName).toBe("Read");
+        expect(turns[0].toolCalls[0].input).toEqual({ file_path: "/tmp/test.ts" });
+    });
+    it("matches tool_result to toolCall by tool_use_id", () => {
+        const lines = [
+            { type: "user", timestamp: "2026-01-01T00:00:00Z", message: { content: "read file" } },
+            {
+                type: "assistant",
+                message: {
+                    content: [
+                        { type: "tool_use", id: "tu1", name: "Read", input: { file_path: "/tmp/a.ts" } },
+                    ],
+                },
+            },
+            {
+                type: "user",
+                message: {
+                    content: [{ type: "tool_result", tool_use_id: "tu1", content: "file contents here" }],
+                },
+            },
+        ];
+        const turns = buildTurns(lines);
+        expect(turns[0].toolCalls[0].result).toBe("file contents here");
+    });
+    it("captures thinking blocks in assistantThinking", () => {
+        const lines = [
+            { type: "user", timestamp: "2026-01-01T00:00:00Z", message: { content: "think" } },
+            {
+                type: "assistant",
+                message: {
+                    content: [
+                        { type: "thinking", thinking: "let me consider..." },
+                        { type: "text", text: "here is my answer" },
+                    ],
+                },
+            },
+        ];
+        const turns = buildTurns(lines);
+        expect(turns[0].assistantThinking).toHaveLength(1);
+        expect(turns[0].assistantThinking[0]).toBe("let me consider...");
+    });
+    it("skips system and file-history-snapshot lines", () => {
+        const lines = [
+            { type: "system", message: { content: "system init" } },
+            { type: "file-history-snapshot", snapshot: { timestamp: "2026-01-01T00:00:00Z" } },
+            { type: "user", timestamp: "2026-01-01T00:00:00Z", message: { content: "hello" } },
+            { type: "assistant", message: { content: [{ type: "text", text: "hi" }] } },
+        ];
+        const turns = buildTurns(lines);
+        expect(turns).toHaveLength(1);
+        expect(turns[0].userPrompt).toBe("hello");
+    });
+    it("truncates Write tool_use content and adds contentLength", () => {
+        const longContent = "x".repeat(1000);
+        const lines = [
+            { type: "user", timestamp: "2026-01-01T00:00:00Z", message: { content: "write file" } },
+            {
+                type: "assistant",
+                message: {
+                    content: [
+                        { type: "tool_use", id: "tu1", name: "Write", input: { file_path: "/tmp/out.ts", content: longContent } },
+                    ],
+                },
+            },
+        ];
+        const turns = buildTurns(lines);
+        const tc = turns[0].toolCalls[0];
+        expect(tc.toolName).toBe("Write");
+        expect(tc.input.content.length).toBeLessThan(longContent.length);
+        expect(tc.input.contentLength).toBe(1000);
+    });
+});
+describe("extractMetadata", () => {
+    const baseSessionFile = {
+        filePath: "/tmp/test.jsonl",
+        sessionId: "test-session-id",
+        projectDir: "-Users-foo-github-com-org-repo",
+        projectDisplayName: "org/repo",
+        subagentFiles: ["/tmp/sub1.jsonl", "/tmp/sub2.jsonl"],
+    };
+    it("extracts cwd, gitBranch, version, slug from first line that has them", () => {
+        const lines = [
+            { type: "user", cwd: "/home/user/project", gitBranch: "main", version: "1.0.0", slug: "my-plan", timestamp: "2026-01-01T00:00:00Z", message: { content: "hello" } },
+            { type: "user", cwd: "/other/path", gitBranch: "dev", version: "2.0.0", slug: "other-plan", timestamp: "2026-01-01T00:01:00Z", message: { content: "world" } },
+        ];
+        const turns = buildTurns(lines);
+        const meta = extractMetadata(baseSessionFile, lines, turns);
+        expect(meta.cwd).toBe("/home/user/project");
+        expect(meta.gitBranch).toBe("main");
+        expect(meta.version).toBe("1.0.0");
+        expect(meta.slug).toBe("my-plan");
+    });
+    it("computes correct createdAt and lastActiveAt", () => {
+        const lines = [
+            { type: "user", timestamp: "2026-01-01T10:00:00Z", message: { content: "first" } },
+            { type: "assistant", timestamp: "2026-01-01T10:05:00Z", message: { content: [{ type: "text", text: "reply" }] } },
+            { type: "user", timestamp: "2026-01-01T10:30:00Z", message: { content: "second" } },
+        ];
+        const turns = buildTurns(lines);
+        const meta = extractMetadata(baseSessionFile, lines, turns);
+        expect(meta.createdAt).toBe("2026-01-01T10:00:00Z");
+        expect(meta.lastActiveAt).toBe("2026-01-01T10:30:00Z");
+    });
+    it("computes durationMinutes correctly", () => {
+        const lines = [
+            { type: "user", timestamp: "2026-01-01T10:00:00Z", message: { content: "start" } },
+            { type: "user", timestamp: "2026-01-01T10:45:00Z", message: { content: "end" } },
+        ];
+        const turns = buildTurns(lines);
+        const meta = extractMetadata(baseSessionFile, lines, turns);
+        expect(meta.durationMinutes).toBe(45);
+    });
+    it("counts tool breakdown from turns", () => {
+        const lines = [
+            { type: "user", timestamp: "2026-01-01T00:00:00Z", message: { content: "do stuff" } },
+            {
+                type: "assistant",
+                message: {
+                    content: [
+                        { type: "tool_use", id: "t1", name: "Read", input: { file_path: "/a.ts" } },
+                        { type: "tool_use", id: "t2", name: "Read", input: { file_path: "/b.ts" } },
+                        { type: "tool_use", id: "t3", name: "Edit", input: { file_path: "/a.ts", old_string: "x", new_string: "y" } },
+                    ],
+                },
+            },
+        ];
+        const turns = buildTurns(lines);
+        const meta = extractMetadata(baseSessionFile, lines, turns);
+        expect(meta.toolBreakdown).toEqual({ Read: 2, Edit: 1 });
+    });
+    it("tracks filesEdited from Edit/Write toolCalls", () => {
+        const lines = [
+            { type: "user", timestamp: "2026-01-01T00:00:00Z", message: { content: "edit files" } },
+            {
+                type: "assistant",
+                message: {
+                    content: [
+                        { type: "tool_use", id: "t1", name: "Edit", input: { file_path: "/src/a.ts", old_string: "x", new_string: "y" } },
+                        { type: "tool_use", id: "t2", name: "Write", input: { file_path: "/src/b.ts", content: "new file" } },
+                        { type: "tool_use", id: "t3", name: "Read", input: { file_path: "/src/c.ts" } },
+                    ],
+                },
+            },
+        ];
+        const turns = buildTurns(lines);
+        const meta = extractMetadata(baseSessionFile, lines, turns);
+        expect(meta.filesEdited.sort()).toEqual(["/src/a.ts", "/src/b.ts"]);
+    });
+    it("counts modelsUsed from assistant messages", () => {
+        const lines = [
+            { type: "user", timestamp: "2026-01-01T00:00:00Z", message: { content: "hello" } },
+            { type: "assistant", timestamp: "2026-01-01T00:00:01Z", message: { model: "claude-sonnet", content: [{ type: "text", text: "hi" }] } },
+            { type: "user", timestamp: "2026-01-01T00:01:00Z", message: { content: "again" } },
+            { type: "assistant", timestamp: "2026-01-01T00:01:01Z", message: { model: "claude-sonnet", content: [{ type: "text", text: "ok" }] } },
+            { type: "assistant", timestamp: "2026-01-01T00:01:02Z", message: { model: "claude-opus", content: [{ type: "text", text: "deep" }] } },
+        ];
+        const turns = buildTurns(lines);
+        const meta = extractMetadata(baseSessionFile, lines, turns);
+        expect(meta.modelsUsed).toEqual({ "claude-sonnet": 2, "claude-opus": 1 });
+    });
+    it("returns sensible defaults for empty turns/lines", () => {
+        const meta = extractMetadata(baseSessionFile, [], []);
+        expect(meta.sessionId).toBe("test-session-id");
+        expect(meta.cwd).toBe("");
+        expect(meta.gitBranch).toBe("");
+        expect(meta.durationMinutes).toBe(0);
+        expect(meta.turnCount).toBe(0);
+        expect(meta.toolBreakdown).toEqual({});
+        expect(meta.filesEdited).toEqual([]);
+        expect(meta.modelsUsed).toEqual({});
+        expect(meta.firstUserPrompt).toBe("");
+        expect(meta.subagentCount).toBe(2);
+    });
+});