@chigichan24/crune 0.1.4 → 0.1.6

package/README.md

@@ -17,7 +17,7 @@ Decipher the traces etched in past sessions and resurrect them as reusable skill
 - **Overview Dashboard** --- Activity heatmap, project distribution, tool usage trends, duration distribution, model usage, and top edited files
 - **Semantic Knowledge Graph** --- TF-IDF + Tool-IDF + structural features, Truncated SVD, agglomerative clustering, Louvain community detection, Brandes centrality ([algorithm details](docs/knowledge-graph-algorithm.md))
 - **Tacit Knowledge** --- Extracted workflow patterns, tool sequences, and pain points (long sessions, hot files)
-- **Session Summarization** --- Automatic session summary and classification (no LLM required)
+- **Session Summarization** --- Automatic session summary and classification (no LLM required), enriched with `/insights` facets data when available
 - **Skill Synthesis** --- Synthesize reusable skill definitions from the knowledge graph ([algorithm details](docs/skill-generation-algorithm.md))
 
 ### Overview Dashboard
@@ -77,8 +77,10 @@ npm run dev
   -> parse & build turns
   -> extract metadata, subagents, linked plans
   -> session summarization (centrality-based representative prompt, workType classification)
-  -> TF-IDF + Tool-IDF + structural features -> Truncated SVD -> agglomerative clustering -> Louvain
-  -> skill synthesis (reusability score top-N -> claude -p)
+  -> TF-IDF + Tool-IDF + structural features -> Truncated SVD -> agglomerative clustering
+  -> /insights facets integration (narrow cluster merging, goal-based labeling)
+  -> Louvain community detection
+  -> skill synthesis (reusability score top-N -> claude -p, enriched with facets insights)
   -> output:
        public/data/sessions/index.json      (session list)
        public/data/sessions/overview.json   (cross-session analytics + knowledge graph)
@@ -91,9 +93,20 @@ Custom paths:
 npm run analyze-sessions -- --sessions-dir /path/to/sessions --output-dir /path/to/output
 ```
 
+### /insights Integration
+
+Before analysis, `analyze-sessions` automatically runs `/insights` to refresh facets data. This enriches the pipeline with:
+- **Better topic labels** using LLM-generated `underlying_goal` instead of TF-IDF keywords
+- **Narrow cluster merging** based on shared goal categories
+- **Quality-aware reusability scoring** using session outcome and helpfulness
+- **Richer synthesis prompts** with friction details and success rates
+- **Session summaries** using `brief_summary` from facets
+
+Skip with `--skip-facets` or customize the facets path with `--facets-dir <path>`.
+
 ## Session Summarization
 
-The session list displays auto-generated summaries, processed entirely locally without LLM.
+The session list displays auto-generated summaries. When `/insights` facets data is available, the LLM-generated `brief_summary` is used. Otherwise, summaries are processed locally without LLM.
 
 - **Representative prompt selection**: Selects the most representative prompt from plan mode turns using Jaccard centrality with position weighting
 - **workType classification**: Automatically classifies each session into one of four types:
@@ -138,13 +151,15 @@ npm run analyze-sessions -- --skip-synthesis
 | `npm run skill-server` | Skill synthesis local server (localhost:3456) |
 | `npm run dev:full` | skill-server + Vite dev server together |
 
-### Synthesis options for analyze-sessions
+### Options for analyze-sessions
 
 | Flag | Description |
 |------|-------------|
 | `--synthesis-model <model>` | Model to use for synthesis (e.g. `haiku` for speed) |
 | `--synthesis-count <n>` | Number of candidates to synthesize (default: 5) |
 | `--skip-synthesis` | Skip LLM synthesis |
+| `--facets-dir <path>` | Custom facets directory (default: `~/.claude/usage-data/facets`) |
+| `--skip-facets` | Skip `/insights` refresh and facets integration |
 
 ## Tech Stack
 
@@ -172,6 +187,8 @@ scripts/
   skill-synthesizer.ts       # Skill synthesis (claude -p)
   skill-server.ts            # Synthesis HTTP server
   knowledge-graph-builder.ts # Semantic embedding + graph construction
+  knowledge-graph/
+    facets-reader.ts         # /insights facets data reader + normalization
 public/
   data/sessions/             # Generated JSON (gitignored)
 ```

package/dist-cli/__tests__/facets-reader.test.js

@@ -0,0 +1,180 @@
+import { describe, it, expect } from "vitest";
+import { normalizeGoalCategory, helpfulnessToScore, aggregateFacetsForTopic, } from "../knowledge-graph-builder.js";
+describe("normalizeGoalCategory", () => {
+    it("maps feature_implementation → feature", () => {
+        expect(normalizeGoalCategory("feature_implementation")).toBe("feature");
+    });
+    it("maps fix_build_errors → bugfix", () => {
+        expect(normalizeGoalCategory("fix_build_errors")).toBe("bugfix");
+    });
+    it("maps debugging → bugfix", () => {
+        expect(normalizeGoalCategory("debugging")).toBe("bugfix");
+    });
+    it("maps refactoring → refactoring", () => {
+        expect(normalizeGoalCategory("refactoring")).toBe("refactoring");
+    });
+    it("maps code_cleanup → refactoring", () => {
+        expect(normalizeGoalCategory("code_cleanup")).toBe("refactoring");
+    });
+    it("maps documentation_update → documentation", () => {
+        expect(normalizeGoalCategory("documentation_update")).toBe("documentation");
+    });
+    it("maps code_review → review", () => {
+        expect(normalizeGoalCategory("code_review")).toBe("review");
+    });
+    it("maps test_writing → testing", () => {
+        expect(normalizeGoalCategory("test_writing")).toBe("testing");
+    });
+    it("maps ci_setup → ci", () => {
+        expect(normalizeGoalCategory("ci_setup")).toBe("ci");
+    });
+    it("maps git_operations → git_ops", () => {
+        expect(normalizeGoalCategory("git_operations")).toBe("git_ops");
+    });
+    it("maps create_pr → git_ops", () => {
+        expect(normalizeGoalCategory("create_pr")).toBe("git_ops");
+    });
+    it("maps pr_creation → git_ops", () => {
+        expect(normalizeGoalCategory("pr_creation")).toBe("git_ops");
+    });
+    it("maps setup_deployment → setup", () => {
+        expect(normalizeGoalCategory("setup_deployment")).toBe("setup");
+    });
+    it("maps npm_publishing_guidance → setup", () => {
+        expect(normalizeGoalCategory("npm_publishing_guidance")).toBe("setup");
+    });
+    it("maps unknown_category → other", () => {
+        expect(normalizeGoalCategory("unknown_category")).toBe("other");
+    });
+    it("maps quick_question → other", () => {
+        expect(normalizeGoalCategory("quick_question")).toBe("other");
+    });
+});
+describe("helpfulnessToScore", () => {
+    it("returns 1.0 for essential", () => {
+        expect(helpfulnessToScore("essential")).toBe(1.0);
+    });
+    it("returns 0.8 for very_helpful", () => {
+        expect(helpfulnessToScore("very_helpful")).toBe(0.8);
+    });
+    it("returns 0.5 for moderately_helpful", () => {
+        expect(helpfulnessToScore("moderately_helpful")).toBe(0.5);
+    });
+    it("returns 0.25 for slightly_helpful", () => {
+        expect(helpfulnessToScore("slightly_helpful")).toBe(0.25);
+    });
+    it("returns 0.0 for unhelpful", () => {
+        expect(helpfulnessToScore("unhelpful")).toBe(0.0);
+    });
+    it("returns 0.5 for unknown string", () => {
+        expect(helpfulnessToScore("something_else")).toBe(0.5);
+    });
+});
+describe("aggregateFacetsForTopic", () => {
+    function makeFacets(overrides = {}) {
+        return {
+            sessionId: "s1",
+            underlyingGoal: "Implement feature X",
+            goalCategories: { feature_implementation: 1 },
+            outcome: "fully_achieved",
+            claudeHelpfulness: "very_helpful",
+            sessionType: "implementation",
+            frictionCounts: {},
+            frictionDetail: "",
+            primarySuccess: "Feature works",
+            briefSummary: "Implemented feature X",
+            ...overrides,
+        };
+    }
+    it("returns undefined when no sessions have facets", () => {
+        const facetsMap = new Map();
+        const result = aggregateFacetsForTopic(["s1", "s2"], facetsMap);
+        expect(result).toBeUndefined();
+    });
+    it("aggregates goals from multiple sessions", () => {
+        const facetsMap = new Map([
+            ["s1", makeFacets({ sessionId: "s1", underlyingGoal: "Goal A" })],
+            ["s2", makeFacets({ sessionId: "s2", underlyingGoal: "Goal B" })],
+            ["s3", makeFacets({ sessionId: "s3", underlyingGoal: "Goal C" })],
+            ["s4", makeFacets({ sessionId: "s4", underlyingGoal: "Goal D" })],
+        ]);
+        const result = aggregateFacetsForTopic(["s1", "s2", "s3", "s4"], facetsMap);
+        expect(result).toBeDefined();
+        // max 3 goals
+        expect(result.aggregatedGoals).toHaveLength(3);
+        expect(result.aggregatedGoals).toContain("Goal A");
+        expect(result.aggregatedGoals).toContain("Goal B");
+        expect(result.aggregatedGoals).toContain("Goal C");
+    });
+    it("computes successRate correctly with mix of achieved and not", () => {
+        const facetsMap = new Map([
+            ["s1", makeFacets({ sessionId: "s1", outcome: "fully_achieved" })],
+            ["s2", makeFacets({ sessionId: "s2", outcome: "mostly_achieved" })],
+            ["s3", makeFacets({ sessionId: "s3", outcome: "not_achieved" })],
+            ["s4", makeFacets({ sessionId: "s4", outcome: "partially_achieved" })],
+        ]);
+        const result = aggregateFacetsForTopic(["s1", "s2", "s3", "s4"], facetsMap);
+        expect(result).toBeDefined();
+        // 2 out of 4 achieved
+        expect(result.successRate).toBe(0.5);
+    });
+    it("computes helpfulnessScore correctly", () => {
+        const facetsMap = new Map([
+            [
+                "s1",
+                makeFacets({ sessionId: "s1", claudeHelpfulness: "essential" }),
+            ],
+            [
+                "s2",
+                makeFacets({ sessionId: "s2", claudeHelpfulness: "unhelpful" }),
+            ],
+        ]);
+        const result = aggregateFacetsForTopic(["s1", "s2"], facetsMap);
+        expect(result).toBeDefined();
+        // (1.0 + 0.0) / 2 = 0.5
+        expect(result.helpfulnessScore).toBe(0.5);
+    });
+    it("merges and sorts friction counts", () => {
+        const facetsMap = new Map([
+            [
+                "s1",
+                makeFacets({
+                    sessionId: "s1",
+                    frictionCounts: { unclear_spec: 3, slow_response: 1 },
+                }),
+            ],
+            [
+                "s2",
+                makeFacets({
+                    sessionId: "s2",
+                    frictionCounts: { unclear_spec: 2, wrong_tool: 5 },
+                }),
+            ],
+        ]);
+        const result = aggregateFacetsForTopic(["s1", "s2"], facetsMap);
+        expect(result).toBeDefined();
+        // unclear_spec: 5, wrong_tool: 5, slow_response: 1
+        expect(result.commonFrictions[0]).toBe("unclear_spec");
+        expect(result.commonFrictions).toContain("wrong_tool");
+        expect(result.commonFrictions).toContain("slow_response");
+    });
+    it("handles sessions without facets with neutral 0.5 for scores", () => {
+        const facetsMap = new Map([
+            [
+                "s1",
+                makeFacets({
+                    sessionId: "s1",
+                    outcome: "fully_achieved",
+                    claudeHelpfulness: "essential",
+                }),
+            ],
+        ]);
+        // s2 has no facets — should get 0.5 for both scores
+        const result = aggregateFacetsForTopic(["s1", "s2"], facetsMap);
+        expect(result).toBeDefined();
+        // successRate: (1.0 + 0.5) / 2 = 0.75
+        expect(result.successRate).toBe(0.75);
+        // helpfulnessScore: (1.0 + 0.5) / 2 = 0.75
+        expect(result.helpfulnessScore).toBe(0.75);
+    });
+});

package/dist-cli/__tests__/merge-narrow-clusters.test.js

@@ -0,0 +1,171 @@
+import { describe, it, expect } from "vitest";
+import { mergeNarrowClusters } from "../knowledge-graph-builder.js";
+// Helper: build a FacetsData object
+function makeFacets(sessionId, goalCategories, outcome = "fully_achieved") {
+    return {
+        sessionId,
+        underlyingGoal: "test goal",
+        goalCategories,
+        outcome,
+        claudeHelpfulness: "essential",
+        sessionType: "single_task",
+        frictionCounts: {},
+        frictionDetail: "",
+        primarySuccess: "multi_file_changes",
+        briefSummary: "test summary",
+    };
+}
+// Helper: build a distance map with key format `${min}:${max}`
+function buildDistMap(entries) {
+    const m = new Map();
+    for (const [i, j, d] of entries) {
+        const lo = Math.min(i, j);
+        const hi = Math.max(i, j);
+        m.set(`${lo}:${hi}`, d);
+    }
+    return m;
+}
+// ─── mergeNarrowClusters ────────────────────────────────────────────────────
+describe("mergeNarrowClusters", () => {
+    it("returns unchanged when no narrow clusters exist", () => {
+        // All clusters have > maxNarrowSize (2) members
+        const clusters = [
+            [0, 1, 2],
+            [3, 4, 5],
+        ];
+        const sessionIds = ["s0", "s1", "s2", "s3", "s4", "s5"];
+        const facetsMap = new Map();
+        const dist = buildDistMap([
+            [0, 1, 0.1], [0, 2, 0.1], [1, 2, 0.1],
+            [3, 4, 0.1], [3, 5, 0.1], [4, 5, 0.1],
+            [0, 3, 0.9], [0, 4, 0.9], [0, 5, 0.9],
+            [1, 3, 0.9], [1, 4, 0.9], [1, 5, 0.9],
+            [2, 3, 0.9], [2, 4, 0.9], [2, 5, 0.9],
+        ]);
+        const result = mergeNarrowClusters(clusters, sessionIds, facetsMap, dist);
+        expect(result).toEqual(clusters);
+    });
+    it("returns unchanged when narrow clusters have no facets data", () => {
+        const clusters = [[0], [1]];
+        const sessionIds = ["s0", "s1"];
+        const facetsMap = new Map(); // empty
+        const dist = buildDistMap([[0, 1, 0.3]]);
+        const result = mergeNarrowClusters(clusters, sessionIds, facetsMap, dist);
+        // Both clusters survive unmerged (no facets to match on)
+        expect(result.length).toBe(2);
+    });
+    it("merges two narrow clusters with shared goal categories and close distance", () => {
+        const clusters = [[0], [1]];
+        const sessionIds = ["s0", "s1"];
+        const facetsMap = new Map([
+            ["s0", makeFacets("s0", { feature_add_button: 1 })],
+            ["s1", makeFacets("s1", { feature_update_header: 1 })],
+        ]);
+        // Both normalize to "feature"
+        const dist = buildDistMap([[0, 1, 0.3]]);
+        const result = mergeNarrowClusters(clusters, sessionIds, facetsMap, dist);
+        expect(result.length).toBe(1);
+        expect([...result[0]].sort()).toEqual([0, 1]);
+    });
+    it("does not merge when goal categories differ", () => {
+        const clusters = [[0], [1]];
+        const sessionIds = ["s0", "s1"];
+        const facetsMap = new Map([
+            ["s0", makeFacets("s0", { feature_add_button: 1 })],
+            ["s1", makeFacets("s1", { fix_bug_crash: 1 })],
+        ]);
+        // "feature" vs "bugfix" - no overlap
+        const dist = buildDistMap([[0, 1, 0.3]]);
+        const result = mergeNarrowClusters(clusters, sessionIds, facetsMap, dist);
+        expect(result.length).toBe(2);
+    });
+    it("does not merge when distance exceeds threshold", () => {
+        const clusters = [[0], [1]];
+        const sessionIds = ["s0", "s1"];
+        const facetsMap = new Map([
+            ["s0", makeFacets("s0", { feature_add_button: 1 })],
+            ["s1", makeFacets("s1", { feature_update_header: 1 })],
+        ]);
+        // Shared category "feature" but distance too far
+        const dist = buildDistMap([[0, 1, 0.9]]);
+        const result = mergeNarrowClusters(clusters, sessionIds, facetsMap, dist, 2, // maxNarrowSize
+        0.7);
+        expect(result.length).toBe(2);
+    });
+    it("respects maxMergedSize limit", () => {
+        // 3 narrow clusters of size 2 each; maxMergedSize = 3
+        const clusters = [[0, 1], [2, 3], [4, 5]];
+        const sessionIds = ["s0", "s1", "s2", "s3", "s4", "s5"];
+        const facetsMap = new Map([
+            ["s0", makeFacets("s0", { feature_x: 1 })],
+            ["s1", makeFacets("s1", { feature_y: 1 })],
+            ["s2", makeFacets("s2", { feature_z: 1 })],
+            ["s3", makeFacets("s3", { feature_w: 1 })],
+            ["s4", makeFacets("s4", { feature_v: 1 })],
+            ["s5", makeFacets("s5", { feature_u: 1 })],
+        ]);
+        // All close distances
+        const entries = [];
+        for (let i = 0; i < 6; i++) {
+            for (let j = i + 1; j < 6; j++) {
+                entries.push([i, j, 0.2]);
+            }
+        }
+        const dist = buildDistMap(entries);
+        // maxMergedSize = 3 means first merge (2+2=4) already exceeds limit
+        const result = mergeNarrowClusters(clusters, sessionIds, facetsMap, dist, 2, // maxNarrowSize
+        0.7, // distanceThreshold
+        3);
+        // No merges possible since 2+2=4 > 3
+        expect(result.length).toBe(3);
+    });
+    it("handles chain merges: A+B then (A+B)+C", () => {
+        // Three singleton narrow clusters, all share "feature" category and are close
+        const clusters = [[0], [1], [2]];
+        const sessionIds = ["s0", "s1", "s2"];
+        const facetsMap = new Map([
+            ["s0", makeFacets("s0", { feature_a: 1 })],
+            ["s1", makeFacets("s1", { feature_b: 1 })],
+            ["s2", makeFacets("s2", { feature_c: 1 })],
+        ]);
+        const dist = buildDistMap([
+            [0, 1, 0.2],
+            [0, 2, 0.3],
+            [1, 2, 0.25],
+        ]);
+        const result = mergeNarrowClusters(clusters, sessionIds, facetsMap, dist, 2, // maxNarrowSize
+        0.7, // distanceThreshold
+        8);
+        // All three should be merged into one cluster
+        expect(result.length).toBe(1);
+        expect([...result[0]].sort()).toEqual([0, 1, 2]);
+    });
+    it("leaves large clusters untouched and only merges narrow ones", () => {
+        // One large cluster [0,1,2], two narrow singletons [3], [4]
+        const clusters = [[0, 1, 2], [3], [4]];
+        const sessionIds = ["s0", "s1", "s2", "s3", "s4"];
+        const facetsMap = new Map([
+            ["s3", makeFacets("s3", { fix_bug_a: 1 })],
+            ["s4", makeFacets("s4", { fix_bug_b: 1 })],
+        ]);
+        // Narrow clusters are close
+        const entries = [];
+        for (let i = 0; i < 5; i++) {
+            for (let j = i + 1; j < 5; j++) {
+                entries.push([i, j, i < 3 && j < 3 ? 0.1 : 0.3]);
+            }
+        }
+        const dist = buildDistMap(entries);
+        const result = mergeNarrowClusters(clusters, sessionIds, facetsMap, dist, 2, // maxNarrowSize
+        0.7, // distanceThreshold
+        8);
+        // Large cluster stays as-is, two narrow clusters merge into one
+        expect(result.length).toBe(2);
+        // The large cluster should be present
+        const sorted = result
+            .map((c) => [...c].sort((a, b) => a - b))
+            .sort((a, b) => a[0] - b[0]);
+        expect(sorted[0]).toEqual([0, 1, 2]);
+        expect(sorted[1]).toEqual([3, 4]);
+    });
+});

package/dist-cli/__tests__/reusability-scoring.test.js

@@ -0,0 +1,175 @@
+import { describe, it, expect } from "vitest";
+import { computeReusabilityScores, } from "../knowledge-graph-builder.js";
+function makeTopic(overrides = {}) {
+    return {
+        id: "topic-001",
+        label: "test",
+        keywords: ["test"],
+        project: "proj",
+        projects: ["proj"],
+        sessionIds: ["s1"],
+        sessionCount: 1,
+        totalDurationMinutes: 60,
+        totalToolCalls: 10,
+        firstSeen: "2026-01-01T00:00:00Z",
+        lastSeen: "2026-03-01T00:00:00Z",
+        betweennessCentrality: 0,
+        degreeCentrality: 0,
+        communityId: 0,
+        representativePrompts: [],
+        suggestedPrompt: "",
+        toolSignature: [],
+        dominantRole: "user-driven",
+        reusabilityScore: { overall: 0, frequency: 0, timeCost: 0, crossProjectScore: 0, recency: 0 },
+        ...overrides,
+    };
+}
+function makeFacets(sessionId, outcome, helpfulness) {
+    return {
+        sessionId,
+        underlyingGoal: "test",
+        goalCategories: {},
+        outcome,
+        claudeHelpfulness: helpfulness,
+        sessionType: "single_task",
+        frictionCounts: {},
+        frictionDetail: "",
+        primarySuccess: "",
+        briefSummary: "",
+    };
+}
+// ─── No facetsMap (backward compatible) ─────────────────────────────────────
+describe("computeReusabilityScores without facets", () => {
+    it("uses original formula weights (0.35/0.25/0.25/0.15)", () => {
+        // Single topic: frequency=1, timeCost=1, crossProject=0, recency=1
+        const topic = makeTopic({
+            sessionCount: 1,
+            totalDurationMinutes: 60,
+            projects: ["proj"],
+            lastSeen: "2026-03-17T00:00:00Z",
+        });
+        const now = new Date("2026-03-17T00:00:00Z");
+        computeReusabilityScores([topic], now);
+        // frequency = 1/1 = 1, timeCost = 60/60 = 1, crossProject = 0 (single project), recency = 1 (same day)
+        // overall = 0.35*1 + 0.25*1 + 0.25*0 + 0.15*1 = 0.75
+        expect(topic.reusabilityScore.overall).toBe(0.75);
+        expect(topic.reusabilityScore.frequency).toBe(1);
+        expect(topic.reusabilityScore.timeCost).toBe(1);
+        expect(topic.reusabilityScore.crossProjectScore).toBe(0);
+        expect(topic.reusabilityScore.recency).toBe(1);
+    });
+});
+// ─── Empty facetsMap (backward compatible) ──────────────────────────────────
+describe("computeReusabilityScores with empty facetsMap", () => {
+    it("behaves same as no facetsMap", () => {
+        const topic = makeTopic({
+            sessionCount: 1,
+            totalDurationMinutes: 60,
+            projects: ["proj"],
+            lastSeen: "2026-03-17T00:00:00Z",
+        });
+        const now = new Date("2026-03-17T00:00:00Z");
+        computeReusabilityScores([topic], now, new Map());
+        expect(topic.reusabilityScore.overall).toBe(0.75);
+        expect(topic.reusabilityScore.successRate).toBeUndefined();
+        expect(topic.reusabilityScore.helpfulness).toBeUndefined();
+    });
+});
+// ─── FacetsMap with full coverage ───────────────────────────────────────────
+describe("computeReusabilityScores with full facets coverage", () => {
+    it("uses new weights (0.30/0.20/0.20/0.10/0.10/0.10) with successRate=1 and helpfulness=1", () => {
+        const topic = makeTopic({
+            sessionIds: ["s1", "s2"],
+            sessionCount: 2,
+            totalDurationMinutes: 120,
+            projects: ["proj"],
+            lastSeen: "2026-03-17T00:00:00Z",
+        });
+        const now = new Date("2026-03-17T00:00:00Z");
+        const facetsMap = new Map();
+        facetsMap.set("s1", makeFacets("s1", "fully_achieved", "essential"));
+        facetsMap.set("s2", makeFacets("s2", "mostly_achieved", "essential"));
+        computeReusabilityScores([topic], now, facetsMap);
+        // frequency=1, timeCost=1, crossProject=0, recency=1, successRate=1, helpfulness=1
+        // overall = 0.30*1 + 0.20*1 + 0.20*0 + 0.10*1 + 0.10*1 + 0.10*1 = 0.80
+        expect(topic.reusabilityScore.overall).toBe(0.8);
+        expect(topic.reusabilityScore.successRate).toBe(1);
+        expect(topic.reusabilityScore.helpfulness).toBe(1);
+    });
+});
+// ─── FacetsMap with partial coverage ────────────────────────────────────────
+describe("computeReusabilityScores with partial facets coverage", () => {
+    it("defaults missing sessions to 0.5 for successRate and helpfulness", () => {
+        const topic = makeTopic({
+            sessionIds: ["s1", "s2"],
+            sessionCount: 2,
+            totalDurationMinutes: 120,
+            projects: ["proj"],
+            lastSeen: "2026-03-17T00:00:00Z",
+        });
+        const now = new Date("2026-03-17T00:00:00Z");
+        // Only s1 has facets
+        const facetsMap = new Map();
+        facetsMap.set("s1", makeFacets("s1", "fully_achieved", "essential"));
+        computeReusabilityScores([topic], now, facetsMap);
+        // successRate = (1.0 + 0.5) / 2 = 0.75
+        // helpfulness = (1.0 + 0.5) / 2 = 0.75
+        expect(topic.reusabilityScore.successRate).toBe(0.75);
+        expect(topic.reusabilityScore.helpfulness).toBe(0.75);
+    });
+});
+// ─── Not achieved + unhelpful lowers score ──────────────────────────────────
+describe("computeReusabilityScores with negative facets", () => {
+    it("sets successRate=0 and helpfulness=0 for not_achieved + unhelpful", () => {
+        const topic = makeTopic({
+            sessionIds: ["s1"],
+            sessionCount: 1,
+            totalDurationMinutes: 60,
+            projects: ["proj"],
+            lastSeen: "2026-03-17T00:00:00Z",
+        });
+        const now = new Date("2026-03-17T00:00:00Z");
+        const facetsMap = new Map();
+        facetsMap.set("s1", makeFacets("s1", "not_achieved", "unhelpful"));
+        computeReusabilityScores([topic], now, facetsMap);
+        expect(topic.reusabilityScore.successRate).toBe(0);
+        expect(topic.reusabilityScore.helpfulness).toBe(0);
+        // overall = 0.30*1 + 0.20*1 + 0.20*0 + 0.10*1 + 0.10*0 + 0.10*0 = 0.60
+        expect(topic.reusabilityScore.overall).toBe(0.6);
+    });
+});
+// ─── Score fields set on ReusabilityScore ───────────────────────────────────
+describe("ReusabilityScore fields with facets", () => {
+    it("sets successRate and helpfulness fields when facetsMap is provided", () => {
+        const topic = makeTopic({
+            sessionIds: ["s1"],
+            sessionCount: 1,
+            totalDurationMinutes: 60,
+            projects: ["proj"],
+            lastSeen: "2026-03-17T00:00:00Z",
+        });
+        const now = new Date("2026-03-17T00:00:00Z");
+        const facetsMap = new Map();
+        facetsMap.set("s1", makeFacets("s1", "fully_achieved", "very_helpful"));
+        computeReusabilityScores([topic], now, facetsMap);
+        expect(topic.reusabilityScore.successRate).toBeDefined();
+        expect(topic.reusabilityScore.helpfulness).toBeDefined();
+        expect(typeof topic.reusabilityScore.successRate).toBe("number");
+        expect(typeof topic.reusabilityScore.helpfulness).toBe("number");
+    });
+});
+// ─── Score fields NOT set when no facets ────────────────────────────────────
+describe("ReusabilityScore fields without facets", () => {
+    it("does not set successRate and helpfulness when no facetsMap", () => {
+        const topic = makeTopic({
+            sessionCount: 1,
+            totalDurationMinutes: 60,
+            projects: ["proj"],
+            lastSeen: "2026-03-17T00:00:00Z",
+        });
+        const now = new Date("2026-03-17T00:00:00Z");
+        computeReusabilityScores([topic], now);
+        expect(topic.reusabilityScore.successRate).toBeUndefined();
+        expect(topic.reusabilityScore.helpfulness).toBeUndefined();
+    });
+});

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

@@ -123,3 +123,20 @@ describe("tokenize", () => {
         expect(tokens).not.toContain("go");
     });
 });
+describe("tokenize - large input regression (Issue #18)", () => {
+    // Real Claude Code sessions can contain `ls -R` / `find` / `tree` dumps
+    // with hundreds of thousands of path segments. `tokens.push(...arr)` on
+    // such an array hits V8's argument count limit and throws
+    // `RangeError: Maximum call stack size exceeded` even though it is not
+    // recursion. See https://github.com/chigichan24/crune/issues/18.
+    it("extractPathTokens does not throw on a huge corpus of file paths", () => {
+        const pathSegments = Array.from({ length: 100_000 }, (_, i) => `/dir${i}/file${i}.ts`);
+        const text = pathSegments.join(" ");
+        expect(() => extractPathTokens(text)).not.toThrow();
+    });
+    it("tokenize does not throw on a huge corpus of file paths", () => {
+        const pathSegments = Array.from({ length: 100_000 }, (_, i) => `/dir${i}/file${i}.ts`);
+        const text = pathSegments.join(" ");
+        expect(() => tokenize(text)).not.toThrow();
+    });
+});