@chigichan24/crune 0.1.0

package/dist-cli/knowledge-graph/skill-generator.js

@@ -0,0 +1,203 @@
+/**
+ * Generates Claude Code skill Markdown and hook JSON from detected patterns.
+ *
+ * Skill format follows the conventions from anthropics/skills (Apache-2.0):
+ * https://github.com/anthropics/skills/tree/main/skills/skill-creator
+ *
+ * Key conventions applied:
+ * - YAML frontmatter with `name` and `description` (description includes "when to use")
+ * - Imperative writing style
+ * - "Why" explanations over bare MUST/NEVER rules
+ * - Concrete examples from representative prompts
+ * - Progressive disclosure: keep SKILL.md body concise
+ */
+// ─── Skill name generation ──────────────────────────────────────────────────
+function toSkillName(keywords, project) {
+    // Use top keywords + project suffix, kebab-case, max 40 chars
+    const parts = keywords
+        .slice(0, 3)
+        .map((k) => k.toLowerCase().replace(/[^a-z0-9]/g, ""))
+        .filter((k) => k.length > 0);
+    const projectSuffix = project
+        .split("/")
+        .pop()
+        ?.toLowerCase()
+        .replace(/[^a-z0-9]/g, "");
+    if (projectSuffix && !parts.includes(projectSuffix)) {
+        parts.push(projectSuffix);
+    }
+    return parts.join("-").slice(0, 40);
+}
+// ─── Description generation (with "pushiness" per skill-creator guidance) ───
+function buildDescription(topic) {
+    // Description should include WHEN to use + WHAT it does.
+    // skill-creator calls this "pushiness" — explicit about trigger context
+    // to counteract under-triggering.
+    const action = topic.suggestedPrompt.split(" — ")[0] || "work on this domain";
+    const tools = topic.toolSignature
+        .slice(0, 3)
+        .map((t) => t.tool)
+        .join(", ");
+    const roleHint = topic.dominantRole === "subagent-delegated"
+        ? "Delegates to specialized subagents."
+        : topic.dominantRole === "tool-heavy"
+            ? `Tool-intensive workflow using ${tools}.`
+            : `Interactive workflow using ${tools}.`;
+    const projectScope = topic.projects.length > 1
+        ? `Applies across ${topic.projects.length} projects (${topic.projects.slice(0, 2).join(", ")}${topic.projects.length > 2 ? ", ..." : ""}).`
+        : `Scoped to ${topic.project}.`;
+    return `Use when you need to ${action}. ${roleHint} ${projectScope} Detected from ${topic.sessionCount} sessions over ${topic.totalDurationMinutes} minutes of usage.`;
+}
+// ─── Skill body generation ──────────────────────────────────────────────────
+function buildSkillBody(topic, relatedSequences) {
+    const sections = [];
+    // Section 1: Overview — what this skill automates and why
+    sections.push("## Overview");
+    sections.push("");
+    sections.push(`This skill captures a recurring workflow pattern detected across ${topic.sessionCount} sessions.`);
+    if (topic.projects.length > 1) {
+        sections.push(`It spans ${topic.projects.length} projects, indicating cross-project reusable knowledge.`);
+    }
+    sections.push("");
+    // Section 2: When to use — explicit trigger guidance (skill-creator: "pushiness")
+    sections.push("## When to Use");
+    sections.push("");
+    if (topic.representativePrompts.length > 0) {
+        sections.push("Activate this skill when the user's request resembles:");
+        for (const prompt of topic.representativePrompts) {
+            sections.push(`- "${prompt}"`);
+        }
+    }
+    else {
+        sections.push(`Activate when working on tasks involving: ${topic.keywords.join(", ")}.`);
+    }
+    sections.push("");
+    // Section 3: Workflow steps — imperative style per skill-creator guidance
+    sections.push("## Workflow");
+    sections.push("");
+    if (topic.dominantRole === "subagent-delegated") {
+        sections.push("Delegate to specialized subagents. This pattern benefits from parallel execution:");
+        sections.push("");
+        sections.push("1. Analyze the task scope and identify subtasks");
+        sections.push("2. Spawn subagents for each independent subtask using the Agent tool");
+        sections.push("3. Collect and synthesize results");
+        sections.push("");
+    }
+    else {
+        // Build steps from tool signature — imperative, concrete
+        sections.push("Follow this tool sequence:");
+        sections.push("");
+        const toolSteps = topic.toolSignature.slice(0, 5);
+        for (let i = 0; i < toolSteps.length; i++) {
+            const ts = toolSteps[i];
+            const purpose = describeToolPurpose(ts.tool);
+            sections.push(`${i + 1}. Use **${ts.tool}** to ${purpose}`);
+        }
+        sections.push("");
+    }
+    // Section 4: Enriched patterns — concrete tool sequences with targets
+    if (relatedSequences.length > 0) {
+        sections.push("## Detected Patterns");
+        sections.push("");
+        sections.push("The following tool call patterns were frequently observed in this workflow:");
+        sections.push("");
+        for (const seq of relatedSequences.slice(0, 3)) {
+            const flow = seq.sequence
+                .map((s) => {
+                const target = s.targetPattern ? ` (${s.targetPattern})` : "";
+                return `${s.toolName}${target}`;
+            })
+                .join(" → ");
+            sections.push(`- \`${flow}\` — ${seq.count} occurrences`);
+        }
+        sections.push("");
+    }
+    // Section 5: Guidelines — why-based, not bare rules
+    sections.push("## Guidelines");
+    sections.push("");
+    if (topic.dominantRole === "tool-heavy") {
+        sections.push("- Prefer tool calls over asking the user, because this pattern historically involves intensive automated operations.");
+    }
+    if (topic.projects.length > 1) {
+        sections.push("- Check project-specific conventions before applying, because this pattern spans multiple projects that may have different standards.");
+    }
+    const readTools = topic.toolSignature.filter((t) => t.tool === "Read" || t.tool === "Grep" || t.tool === "Glob");
+    if (readTools.length > 0) {
+        sections.push("- Read and understand existing code before making changes, because this pattern involves significant code exploration.");
+    }
+    sections.push("");
+    return sections.join("\n");
+}
+function describeToolPurpose(tool) {
+    switch (tool) {
+        case "Read":
+            return "examine existing files and understand current state";
+        case "Grep":
+            return "search for relevant patterns and references";
+        case "Glob":
+            return "locate target files by pattern";
+        case "Edit":
+            return "apply targeted modifications to existing files";
+        case "Write":
+            return "create new files as needed";
+        case "Bash":
+            return "execute commands (build, test, git operations)";
+        case "Agent":
+            return "delegate subtasks to specialized subagents";
+        default:
+            return `perform ${tool} operations`;
+    }
+}
+// ─── Public API ─────────────────────────────────────────────────────────────
+export function generateSkillMarkdown(topic, relatedSequences = []) {
+    const name = toSkillName(topic.keywords, topic.project);
+    const description = buildDescription(topic);
+    const body = buildSkillBody(topic, relatedSequences);
+    return `---
+name: ${name}
+description: >-
+  ${description}
+---
+
+# ${topic.keywords.slice(0, 3).join(" / ")}
+
+${body}`.trim();
+}
+export function generateHookJson(sequence) {
+    // Only generate hooks for patterns involving Bash commands with identifiable categories
+    const bashSteps = sequence.sequence.filter((s) => s.toolName === "Bash" && s.targetPattern && s.targetPattern !== "other");
+    if (bashSteps.length === 0)
+        return undefined;
+    const hookDef = {
+        description: `Auto-detected pattern from ${sequence.count} occurrences across ${sequence.projects.length} project(s)`,
+        pattern: sequence.sequence.map((s) => ({
+            tool: s.toolName,
+            category: s.category,
+            target: s.targetPattern || null,
+        })),
+        sessionCount: sequence.count,
+        projects: sequence.projects,
+    };
+    return JSON.stringify(hookDef, null, 2);
+}
+export function generateSkillCandidates(topics, enrichedSequences) {
+    const candidates = [];
+    // Generate skill candidates from topics sorted by reusability score
+    const sorted = [...topics].sort((a, b) => b.reusabilityScore.overall - a.reusabilityScore.overall);
+    for (const topic of sorted) {
+        // Find enriched sequences related to this topic's sessions
+        const topicSessionSet = new Set(topic.sessionIds);
+        const relatedSequences = enrichedSequences.filter((seq) => seq.sessionIds.some((sid) => topicSessionSet.has(sid)));
+        const skillMarkdown = generateSkillMarkdown(topic, relatedSequences);
+        const hookJson = relatedSequences.length > 0
+            ? generateHookJson(relatedSequences[0])
+            : undefined;
+        candidates.push({
+            topicId: topic.id,
+            reusabilityScore: topic.reusabilityScore.overall,
+            skillMarkdown,
+            hookJson,
+        });
+    }
+    return candidates;
+}

package/dist-cli/knowledge-graph/svd.js

@@ -0,0 +1,195 @@
+/**
+ * Truncated SVD (Latent Semantic Analysis) via Gram matrix power iteration.
+ */
+import { WEIGHT_TEXT, WEIGHT_TOOL, WEIGHT_STRUCT } from "./constants.js";
+/**
+ * Build a combined feature matrix from text, tool, and structural vectors.
+ * Each group is L2-normalized, then scaled by its weight before concatenation.
+ * Returns a dense row-major matrix (m × n) and sessionId ordering.
+ */
+export function buildCombinedMatrix(sessionIds, textVectors, toolVectors, structVectors, textDim, toolDim, structDim) {
+    const totalDim = textDim + toolDim + structDim;
+    const wt = Math.sqrt(WEIGHT_TEXT);
+    const wl = Math.sqrt(WEIGHT_TOOL);
+    const ws = Math.sqrt(WEIGHT_STRUCT);
+    const matrix = [];
+    for (const sid of sessionIds) {
+        const row = new Float64Array(totalDim);
+        const tv = textVectors.get(sid);
+        const lv = toolVectors.get(sid);
+        const sv = structVectors.get(sid);
+        if (tv)
+            for (let i = 0; i < textDim; i++)
+                row[i] = tv[i] * wt;
+        if (lv)
+            for (let i = 0; i < toolDim; i++)
+                row[textDim + i] = lv[i] * wl;
+        if (sv)
+            for (let i = 0; i < structDim; i++)
+                row[textDim + toolDim + i] = sv[i] * ws;
+        matrix.push(row);
+    }
+    return { matrix, totalDim };
+}
+/**
+ * Truncated SVD via power iteration on A·A^T (the Gram matrix).
+ *
+ * For m sessions × n features where m << n, computing the m×m Gram matrix
+ * and extracting its top-k eigenvectors is far cheaper than full SVD.
+ */
+export function truncatedSvd(sessionIds, matrix, totalDim, targetK) {
+    const m = matrix.length;
+    const n = totalDim;
+    const k = Math.min(targetK, m - 1, n);
+    // Step 1: Compute Gram matrix G = A · A^T (m × m)
+    const G = new Float64Array(m * m);
+    for (let i = 0; i < m; i++) {
+        for (let j = i; j < m; j++) {
+            let dot = 0;
+            for (let d = 0; d < n; d++) {
+                dot += matrix[i][d] * matrix[j][d];
+            }
+            G[i * m + j] = dot;
+            G[j * m + i] = dot;
+        }
+    }
+    // Step 2: Power iteration with deflation to extract top-k eigenvectors of G
+    const eigenvectors = [];
+    const eigenvalues = [];
+    // Seeded PRNG for reproducibility
+    let seed = 42;
+    const nextRand = () => {
+        seed = (seed * 1103515245 + 12345) & 0x7fffffff;
+        return seed / 0x7fffffff;
+    };
+    for (let ki = 0; ki < k; ki++) {
+        // Random initial vector
+        const v = new Float64Array(m);
+        for (let i = 0; i < m; i++)
+            v[i] = nextRand() - 0.5;
+        // Normalize
+        let norm = 0;
+        for (let i = 0; i < m; i++)
+            norm += v[i] * v[i];
+        norm = Math.sqrt(norm);
+        for (let i = 0; i < m; i++)
+            v[i] /= norm;
+        // Power iteration (50 iterations is more than enough for convergence)
+        for (let iter = 0; iter < 50; iter++) {
+            // w = G · v
+            const w = new Float64Array(m);
+            for (let i = 0; i < m; i++) {
+                let s = 0;
+                for (let j = 0; j < m; j++) {
+                    s += G[i * m + j] * v[j];
+                }
+                w[i] = s;
+            }
+            // Deflate: remove projections onto previously found eigenvectors
+            for (let prev = 0; prev < ki; prev++) {
+                const ev = eigenvectors[prev];
+                let proj = 0;
+                for (let i = 0; i < m; i++)
+                    proj += w[i] * ev[i];
+                for (let i = 0; i < m; i++)
+                    w[i] -= proj * ev[i];
+            }
+            // Normalize
+            norm = 0;
+            for (let i = 0; i < m; i++)
+                norm += w[i] * w[i];
+            norm = Math.sqrt(norm);
+            if (norm < 1e-12)
+                break;
+            for (let i = 0; i < m; i++)
+                v[i] = w[i] / norm;
+        }
+        // Eigenvalue = v^T G v
+        let eigenvalue = 0;
+        for (let i = 0; i < m; i++) {
+            let s = 0;
+            for (let j = 0; j < m; j++)
+                s += G[i * m + j] * v[j];
+            eigenvalue += v[i] * s;
+        }
+        eigenvectors.push(new Float64Array(v));
+        eigenvalues.push(Math.max(0, eigenvalue));
+    }
+    // Step 3: Singular values = sqrt(eigenvalues of G)
+    const sigma = new Float64Array(k);
+    for (let i = 0; i < k; i++) {
+        sigma[i] = Math.sqrt(eigenvalues[i]);
+    }
+    // Step 4: Right singular vectors V = A^T · U · Σ^{-1}
+    const V = [];
+    for (let ki = 0; ki < k; ki++) {
+        const vk = new Float64Array(n);
+        if (sigma[ki] > 1e-12) {
+            const invSigma = 1 / sigma[ki];
+            for (let j = 0; j < n; j++) {
+                let s = 0;
+                for (let i = 0; i < m; i++) {
+                    s += matrix[i][j] * eigenvectors[ki][i];
+                }
+                vk[j] = s * invSigma;
+            }
+        }
+        V.push(vk);
+    }
+    // Step 5: Session vectors = U · Σ (scaled embeddings)
+    const sessionVectors = new Map();
+    for (let i = 0; i < m; i++) {
+        const vec = new Float64Array(k);
+        for (let ki = 0; ki < k; ki++) {
+            vec[ki] = eigenvectors[ki][i] * sigma[ki];
+        }
+        // L2 normalize for cosine-based clustering
+        let norm = 0;
+        for (let d = 0; d < k; d++)
+            norm += vec[d] * vec[d];
+        norm = Math.sqrt(norm);
+        if (norm > 0)
+            for (let d = 0; d < k; d++)
+                vec[d] /= norm;
+        sessionVectors.set(sessionIds[i], vec);
+    }
+    return { U: eigenvectors, sigma, V, k, sessionVectors };
+}
+/**
+ * Interpret latent dimensions from V matrix.
+ * Returns top-N terms per latent dimension, useful for cluster labeling.
+ */
+export function interpretLatentDimensions(svd, textVocabulary, toolVocabulary, textDim, toolDim, topN = 5) {
+    const totalVariance = svd.sigma.reduce((s, v) => s + v * v, 0);
+    const dimensions = [];
+    for (let ki = 0; ki < svd.k; ki++) {
+        const v = svd.V[ki];
+        const varianceRatio = totalVariance > 0
+            ? (svd.sigma[ki] * svd.sigma[ki]) / totalVariance
+            : 0;
+        // Top text terms (from text portion of V)
+        const textScored = [];
+        for (let i = 0; i < textDim && i < textVocabulary.length; i++) {
+            if (Math.abs(v[i]) > 0.01) {
+                textScored.push({ term: textVocabulary[i], weight: Math.abs(v[i]) });
+            }
+        }
+        textScored.sort((a, b) => b.weight - a.weight);
+        // Top tools (from tool portion of V)
+        const toolScored = [];
+        for (let i = 0; i < toolDim && i < toolVocabulary.length; i++) {
+            const idx = textDim + i;
+            if (Math.abs(v[idx]) > 0.01) {
+                toolScored.push({ tool: toolVocabulary[i], weight: Math.abs(v[idx]) });
+            }
+        }
+        toolScored.sort((a, b) => b.weight - a.weight);
+        dimensions.push({
+            index: ki,
+            varianceRatio: Math.round(varianceRatio * 10000) / 10000,
+            topTerms: textScored.slice(0, topN),
+            topTools: toolScored.slice(0, topN),
+        });
+    }
+    return dimensions;
+}

package/dist-cli/knowledge-graph/tfidf.js

@@ -0,0 +1,54 @@
+/**
+ * TF-IDF vectorization for session documents.
+ */
+export function buildTfidf(documents) {
+    // Build vocabulary
+    const df = new Map(); // document frequency
+    for (const [, tokens] of documents) {
+        const uniqueTerms = new Set(tokens);
+        for (const term of uniqueTerms) {
+            df.set(term, (df.get(term) || 0) + 1);
+        }
+    }
+    // Filter vocabulary: appear in at least 2 docs, but not in > 80% of docs
+    const n = documents.size;
+    const maxDf = Math.max(2, Math.floor(n * 0.8));
+    const vocabulary = [];
+    const vocabIndex = new Map();
+    for (const [term, count] of df) {
+        if (count >= 2 && count <= maxDf) {
+            vocabIndex.set(term, vocabulary.length);
+            vocabulary.push(term);
+        }
+    }
+    // Build TF-IDF vectors
+    const vectors = new Map();
+    for (const [docId, tokens] of documents) {
+        const tf = new Map();
+        for (const t of tokens) {
+            if (vocabIndex.has(t)) {
+                tf.set(t, (tf.get(t) || 0) + 1);
+            }
+        }
+        const vec = new Float64Array(vocabulary.length);
+        for (const [term, count] of tf) {
+            const idx = vocabIndex.get(term);
+            const termFreq = Math.log(1 + count);
+            const invDocFreq = Math.log(n / (df.get(term) || 1));
+            vec[idx] = termFreq * invDocFreq;
+        }
+        // L2 normalize
+        let norm = 0;
+        for (let i = 0; i < vec.length; i++) {
+            norm += vec[i] * vec[i];
+        }
+        norm = Math.sqrt(norm);
+        if (norm > 0) {
+            for (let i = 0; i < vec.length; i++) {
+                vec[i] /= norm;
+            }
+        }
+        vectors.set(docId, vec);
+    }
+    return { vocabulary, vocabIndex, vectors };
+}

package/dist-cli/knowledge-graph/tokenizer.js

@@ -0,0 +1,66 @@
+/**
+ * Text tokenization for knowledge graph feature extraction.
+ */
+import { STOP_WORDS, UUID_PATTERN, HEX_PATTERN, NUM_PATTERN } from "./constants.js";
+export function splitCamelCase(word) {
+    return word
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .split(/\s+/)
+        .map((w) => w.toLowerCase());
+}
+export function extractPathTokens(text) {
+    const pathPattern = /(?:\/[\w.-]+){2,}/g;
+    const tokens = [];
+    let match;
+    while ((match = pathPattern.exec(text)) !== null) {
+        const segments = match[0].split("/").filter(Boolean);
+        for (const seg of segments) {
+            const name = seg.replace(/\.[^.]+$/, ""); // remove extension
+            if (name.length > 2) {
+                tokens.push(...splitCamelCase(name));
+            }
+        }
+    }
+    return tokens;
+}
+export function isNoiseToken(token) {
+    return (UUID_PATTERN.test(token) ||
+        HEX_PATTERN.test(token) ||
+        NUM_PATTERN.test(token) ||
+        token.length > 40 // extremely long tokens are noise
+    );
+}
+export function tokenize(text) {
+    const tokens = [];
+    // Extract file path tokens first
+    tokens.push(...extractPathTokens(text));
+    // Split on whitespace, punctuation, CJK boundaries
+    const words = text
+        .replace(/[`'"{}()[\]<>;:,!?@#$%^&*=+|\\~]/g, " ")
+        .replace(/\//g, " ")
+        .split(/\s+/)
+        .filter(Boolean);
+    for (const word of words) {
+        // Skip URLs and UUIDs
+        if (word.startsWith("http"))
+            continue;
+        if (UUID_PATTERN.test(word))
+            continue;
+        // Handle kebab-case and snake_case
+        const parts = word.split(/[-_]/).filter(Boolean);
+        for (const part of parts) {
+            // Split CamelCase
+            const subTokens = splitCamelCase(part);
+            for (const t of subTokens) {
+                const clean = t.toLowerCase().replace(/[^a-z0-9\u3040-\u9fff]/g, "");
+                if (clean.length > 2 &&
+                    !STOP_WORDS.has(clean) &&
+                    !isNoiseToken(clean)) {
+                    tokens.push(clean);
+                }
+            }
+        }
+    }
+    return tokens;
+}

package/dist-cli/knowledge-graph/tool-pattern.js

@@ -0,0 +1,173 @@
+/**
+ * Enriched tool sequence extraction with parameter abstraction.
+ * Extracts variable-length tool call patterns with context (file patterns, command categories).
+ */
+// ─── Tool call abstraction ──────────────────────────────────────────────────
+const TOOL_CATEGORY_MAP = {
+    Read: "read",
+    Grep: "search",
+    Glob: "search",
+    Edit: "write",
+    Write: "write",
+    Bash: "execute",
+    Agent: "delegate",
+};
+const BASH_CATEGORIES = [
+    [/^git\s/, "git"],
+    [/^npm\s|^npx\s|^yarn\s|^pnpm\s/, "npm"],
+    [/test|jest|vitest|mocha|pytest/, "test"],
+    [/build|tsc|webpack|vite\s+build|esbuild/, "build"],
+    [/lint|eslint|prettier/, "lint"],
+    [/docker|kubectl|helm/, "container"],
+    [/curl|wget|fetch/, "http"],
+    [/mkdir|rm\s|cp\s|mv\s|chmod|chown/, "filesystem"],
+    [/cat\s|head\s|tail\s|less\s|grep\s/, "read"],
+];
+function classifyBashCommand(command) {
+    const trimmed = command.trim();
+    for (const [pattern, category] of BASH_CATEGORIES) {
+        if (pattern.test(trimmed))
+            return category;
+    }
+    return "other";
+}
+function abstractFilePath(filePath) {
+    const parts = filePath.split("/");
+    if (parts.length <= 1)
+        return filePath;
+    const ext = filePath.match(/\.[a-zA-Z0-9]+$/)?.[0] || "";
+    // Keep first 2 meaningful directory segments + extension pattern
+    const dirs = parts.slice(0, -1).filter((p) => p.length > 0);
+    const prefix = dirs.slice(0, 2).join("/");
+    return prefix ? `${prefix}/**/*${ext}` : `**/*${ext}`;
+}
+export function abstractToolCall(toolCall) {
+    const category = TOOL_CATEGORY_MAP[toolCall.toolName] || "execute";
+    let targetPattern;
+    switch (toolCall.toolName) {
+        case "Edit":
+        case "Write":
+        case "Read": {
+            const fp = toolCall.input.file_path;
+            if (typeof fp === "string") {
+                targetPattern = abstractFilePath(fp);
+            }
+            break;
+        }
+        case "Bash": {
+            const cmd = toolCall.input.command;
+            if (typeof cmd === "string") {
+                targetPattern = classifyBashCommand(cmd);
+            }
+            break;
+        }
+        case "Grep": {
+            const pattern = toolCall.input.pattern;
+            if (typeof pattern === "string") {
+                targetPattern = `grep:${pattern.length > 30 ? pattern.slice(0, 30) + "..." : pattern}`;
+            }
+            break;
+        }
+        case "Glob": {
+            const pattern = toolCall.input.pattern;
+            if (typeof pattern === "string") {
+                targetPattern = `glob:${pattern}`;
+            }
+            break;
+        }
+        case "Agent": {
+            const agentType = toolCall.input.subagent_type;
+            if (typeof agentType === "string") {
+                targetPattern = agentType;
+            }
+            break;
+        }
+    }
+    return { toolName: toolCall.toolName, category, targetPattern };
+}
+// ─── Enriched sequence extraction ───────────────────────────────────────────
+function stepKey(step) {
+    return `${step.toolName}:${step.category}:${step.targetPattern || ""}`;
+}
+function sequenceKey(steps) {
+    return steps.map(stepKey).join("|");
+}
+export function extractEnrichedSequences(sessions, minN = 3, maxN = 7, minCount = 2) {
+    // Collect all abstracted tool steps per session
+    const sessionSteps = [];
+    for (const session of sessions) {
+        const steps = [];
+        for (const turn of session.turns) {
+            for (const tc of turn.toolCalls) {
+                steps.push(abstractToolCall(tc));
+            }
+        }
+        // Include subagent tool calls
+        for (const sub of Object.values(session.subagents)) {
+            for (const turn of sub.turns) {
+                for (const tc of turn.toolCalls) {
+                    steps.push(abstractToolCall(tc));
+                }
+            }
+        }
+        if (steps.length >= minN) {
+            sessionSteps.push({
+                sessionId: session.sessionId,
+                project: session.projectDisplayName,
+                steps,
+            });
+        }
+    }
+    // Extract n-grams for each length
+    const allSequences = new Map();
+    for (let n = minN; n <= maxN; n++) {
+        for (const { sessionId, project, steps } of sessionSteps) {
+            if (steps.length < n)
+                continue;
+            for (let i = 0; i <= steps.length - n; i++) {
+                const ngram = steps.slice(i, i + n);
+                const key = sequenceKey(ngram);
+                const existing = allSequences.get(key);
+                if (existing) {
+                    existing.count++;
+                    existing.sessionIds.add(sessionId);
+                    existing.projects.add(project);
+                }
+                else {
+                    allSequences.set(key, {
+                        steps: ngram,
+                        count: 1,
+                        sessionIds: new Set([sessionId]),
+                        projects: new Set([project]),
+                    });
+                }
+            }
+        }
+    }
+    // Filter by minimum count
+    const frequent = [...allSequences.entries()]
+        .filter(([, v]) => v.count >= minCount)
+        .sort((a, b) => b[1].count - a[1].count);
+    // Maximal pattern mining: remove shorter patterns subsumed by longer ones
+    const frequentKeys = new Set(frequent.map(([k]) => k));
+    const result = [];
+    for (const [key, acc] of frequent) {
+        // Check if this pattern is a strict substring of any longer frequent pattern
+        const isSubsumed = frequent.some(([otherKey, otherAcc]) => {
+            return (otherKey !== key &&
+                otherAcc.steps.length > acc.steps.length &&
+                otherAcc.count >= acc.count * 0.8 && // longer pattern captures >=80% of occurrences
+                frequentKeys.has(otherKey) &&
+                otherKey.includes(key));
+        });
+        if (!isSubsumed) {
+            result.push({
+                sequence: acc.steps,
+                count: acc.count,
+                sessionIds: [...acc.sessionIds],
+                projects: [...acc.projects],
+            });
+        }
+    }
+    return result.slice(0, 30); // Top 30 patterns
+}