skill-tree-ai 1.0.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "skill-tree-ai",
+  "version": "1.0.0",
+  "description": "Your AI collaboration style — skill tree visualization with character archetype cards and growth recommendations, grounded in the AI Fluency Framework",
+  "author": {
+    "name": "Robert Nowell",
+    "url": "https://github.com/robertnowell"
+  },
+  "homepage": "https://github.com/robertnowell/skill-tree",
+  "keywords": ["skill-tree", "ai-fluency", "education", "mcp", "growth"],
+  "license": "MIT"
+}

package/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "skill-tree": {
+      "command": "npx",
+      "args": ["-y", "skill-tree-ai"]
+    }
+  }
+}

package/README.md

@@ -0,0 +1,58 @@
+# Skill Tree — AI Fluency Profile for Claude
+
+Analyze your Claude collaboration style. Get a character archetype card, skill tree visualization, and personalized growth recommendations — grounded in [Anthropic's AI Fluency Framework](https://www.anthropic.com/research/AI-fluency-index).
+
+## Install
+
+```bash
+# From this directory
+claude plugin install .
+
+# Or from GitHub
+claude plugin install github:robertnowell/skill-tree
+```
+
+## Use
+
+In any Claude Code session:
+
+```
+/skill-tree
+```
+
+This analyzes your conversation history (Claude Code + Cowork), classifies 11 AI collaboration behaviors, and opens a beautiful visualization in your browser.
+
+## What You Get
+
+**Character Card** — Your archetype (e.g., "The Architect"), tagline, signature strengths, and vibe description
+
+**Skill Tree** — 11 behaviors across 4 branches, with animated bars showing your rate vs. population average:
+- **Planning**: Goal clarity, approach consultation
+- **Craft**: Iteration, examples, format, tone, audience
+- **Judgment**: Context gap detection, reasoning challenges
+- **Rigor**: Fact verification
+
+**Growth Quest** — One specific, actionable challenge for your next session, injected via SessionStart hook
+
+## Requirements
+
+- Python 3.10+
+- `anthropic` Python SDK (`pip3 install anthropic`)
+- `ANTHROPIC_API_KEY` environment variable
+
+## How It Works
+
+1. Scans `~/.claude/projects/` and Cowork local sessions for conversation history
+2. Extracts clean user messages (filters out tool results, pasted output, system messages)
+3. Classifies 11 behaviors per session using Claude Haiku (~$0.005/session, cached)
+4. Aggregates into a skill profile with population baseline comparisons
+5. Generates a character archetype card
+6. Renders a self-contained HTML visualization
+
+## Research Basis
+
+The 11 behaviors come from Anthropic's [AI Fluency Index](https://www.anthropic.com/research/AI-fluency-index) (Feb 2026), which analyzed 9,830 conversations using the [4D AI Fluency Framework](https://aifluencyframework.org/) (Delegation, Description, Discernment, Diligence). Population baselines are from that study.
+
+## License
+
+MIT

package/dist/core/classify.js

@@ -0,0 +1,171 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+// Published population baselines from the AI Fluency Index (Feb 2026)
+export const BASELINES = {
+    iterative_improvement: 0.857,
+    clarify_goals: 0.511,
+    show_examples: 0.411,
+    specify_format: 0.3,
+    set_interactive_mode: 0.3,
+    express_tone_style: 0.227,
+    identify_context_gaps: 0.203,
+    define_audience: 0.176,
+    question_reasoning: 0.158,
+    consult_approach: 0.101,
+    verify_facts: 0.087,
+};
+export const BEHAVIOR_LABELS = {
+    iterative_improvement: "Iterates on outputs",
+    clarify_goals: "Clarifies goals upfront",
+    show_examples: "Provides examples",
+    specify_format: "Specifies format",
+    set_interactive_mode: "Sets interaction style",
+    express_tone_style: "Expresses tone prefs",
+    identify_context_gaps: "Flags context gaps",
+    define_audience: "Defines audience",
+    question_reasoning: "Questions Claude's logic",
+    consult_approach: "Discusses approach first",
+    verify_facts: "Verifies facts",
+};
+// 3-axis system derived from artifact effect data (AI Fluency Index, Feb 2026)
+// Specification behaviors INCREASE with polished artifacts
+// Evaluation behaviors DECREASE with polished artifacts
+// Setup behaviors are independent
+export const AXES = {
+    Specification: {
+        behaviors: ["show_examples", "specify_format", "express_tone_style", "define_audience"],
+        color: "#cca67b",
+        description: "How you shape Claude's output",
+        baseline: 0.28, // avg of individual baselines
+    },
+    Evaluation: {
+        behaviors: ["identify_context_gaps", "question_reasoning", "verify_facts"],
+        color: "#7bcc96",
+        description: "How you assess Claude's reasoning",
+        baseline: 0.15,
+    },
+    Setup: {
+        behaviors: ["clarify_goals", "consult_approach", "set_interactive_mode"],
+        color: "#7ba3cc",
+        description: "How you set up the collaboration",
+        baseline: 0.30,
+    },
+};
+const CLASSIFIER_PROMPT = `You are analyzing a user's conversation with Claude to detect specific AI collaboration behaviors.
+
+Given the user's messages from a single session, classify whether each of the following 11 behaviors is PRESENT or ABSENT. These behaviors come from the AI Fluency Framework.
+
+For each behavior, respond with:
+- present: true/false
+- confidence: "high" or "low"
+- evidence: A brief quote or description of the moment that triggered this classification (or "none" if absent)
+
+THE 11 BEHAVIORS:
+
+1. ITERATIVE_IMPROVEMENT: User builds on previous exchanges to refine work, rather than accepting Claude's first response.
+2. CLARIFY_GOALS: User states their objective or context before requesting assistance.
+3. SHOW_EXAMPLES: User provides examples of desired output, reference material, or illustrative samples.
+4. SPECIFY_FORMAT: User states how output should be organized, formatted, or structured.
+5. SET_INTERACTIVE_MODE: User requests Claude maintain a certain interaction style (e.g., "be concise", "ask me questions", "think step by step").
+6. EXPRESS_TONE_STYLE: User specifies communication tone or writing style preferences.
+7. IDENTIFY_CONTEXT_GAPS: User notes gaps in information Claude might need, or proactively provides context Claude is missing.
+8. DEFINE_AUDIENCE: User specifies who the deliverable is for (e.g., "explain this to a 5-year-old", "this is for senior engineers").
+9. QUESTION_REASONING: User challenges Claude's explanations, logic, or approach — pushes back when something seems wrong.
+10. CONSULT_APPROACH: User asks Claude to review or discuss strategy/approach before starting execution.
+11. VERIFY_FACTS: User fact-checks critical information Claude provides, or asks Claude to verify its own claims.
+
+USER MESSAGES FROM THIS SESSION:
+---
+{MESSAGES}
+---
+
+Respond in valid JSON with this exact structure:
+{
+  "behaviors": {
+    "iterative_improvement": {"present": true, "confidence": "high", "evidence": "..."},
+    "clarify_goals": {"present": true, "confidence": "high", "evidence": "..."},
+    "show_examples": {"present": false, "confidence": "high", "evidence": "none"},
+    "specify_format": {"present": false, "confidence": "high", "evidence": "none"},
+    "set_interactive_mode": {"present": false, "confidence": "high", "evidence": "none"},
+    "express_tone_style": {"present": false, "confidence": "high", "evidence": "none"},
+    "identify_context_gaps": {"present": false, "confidence": "high", "evidence": "none"},
+    "define_audience": {"present": false, "confidence": "high", "evidence": "none"},
+    "question_reasoning": {"present": false, "confidence": "high", "evidence": "none"},
+    "consult_approach": {"present": false, "confidence": "high", "evidence": "none"},
+    "verify_facts": {"present": false, "confidence": "high", "evidence": "none"}
+  },
+  "session_summary": "One sentence describing what this session was about"
+}`;
+function getCacheDir() {
+    const dir = join(homedir(), ".skill-tree", "cache");
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+function getCachedClassification(sessionId) {
+    const cachePath = join(getCacheDir(), `${sessionId}.json`);
+    if (!existsSync(cachePath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(cachePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function cacheClassification(classification) {
+    const cachePath = join(getCacheDir(), `${classification.sessionId}.json`);
+    writeFileSync(cachePath, JSON.stringify(classification, null, 2));
+}
+export async function classifySession(client, sessionId, messages) {
+    const cached = getCachedClassification(sessionId);
+    if (cached)
+        return cached;
+    let messageText = messages
+        .map((m, i) => `[Message ${i + 1}]: ${m.text}`)
+        .join("\n\n---\n\n");
+    if (messageText.length > 10000) {
+        messageText = messageText.slice(0, 10000) + "\n\n[... truncated ...]";
+    }
+    const prompt = CLASSIFIER_PROMPT.replace("{MESSAGES}", messageText);
+    const response = await client.messages.create({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 2000,
+        messages: [{ role: "user", content: prompt }],
+    });
+    const text = response.content[0].type === "text" ? response.content[0].text : "";
+    const jsonStart = text.indexOf("{");
+    const jsonEnd = text.lastIndexOf("}") + 1;
+    if (jsonStart < 0 || jsonEnd <= jsonStart) {
+        throw new Error(`Failed to parse classifier response: ${text.slice(0, 200)}`);
+    }
+    const parsed = JSON.parse(text.slice(jsonStart, jsonEnd));
+    const classification = {
+        sessionId,
+        behaviors: parsed.behaviors,
+        sessionSummary: parsed.session_summary || "Unknown session",
+        classifiedAt: new Date().toISOString(),
+    };
+    cacheClassification(classification);
+    return classification;
+}
+export async function classifySessions(client, sessions, maxNew = 50, onProgress) {
+    const results = [];
+    let newClassified = 0;
+    for (let i = 0; i < sessions.length; i++) {
+        const session = sessions[i];
+        const cached = getCachedClassification(session.sessionId);
+        if (cached) {
+            results.push(cached);
+        }
+        else if (newClassified < maxNew) {
+            const classification = await classifySession(client, session.sessionId, session.messages);
+            results.push(classification);
+            newClassified++;
+        }
+        onProgress?.(i + 1, sessions.length);
+    }
+    return results;
+}

package/dist/core/extract.js

@@ -0,0 +1,179 @@
+import { readFileSync, readdirSync, statSync, existsSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+// Markers indicating pasted Claude Code terminal output (not genuine user input)
+const PASTE_MARKERS = [
+    "▗ ▗",
+    "▘▘ ▝▝",
+    "⏺",
+    "⎿",
+    "✻ Brewed",
+    "✻ Sautéed",
+    "✻ Baked",
+    "ctrl+o to expand",
+];
+function isPastedOutput(text) {
+    const sample = text.slice(0, 500);
+    let markerCount = 0;
+    for (const marker of PASTE_MARKERS) {
+        if (sample.includes(marker))
+            markerCount++;
+    }
+    return markerCount >= 2;
+}
+export function extractUserMessages(jsonlPath) {
+    const messages = [];
+    const content = readFileSync(jsonlPath, "utf-8");
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (obj.type !== "user")
+            continue;
+        const msgContent = obj.message?.content;
+        // Handle string content (direct user input)
+        if (typeof msgContent === "string") {
+            if (isPastedOutput(msgContent))
+                continue;
+            const cleaned = msgContent.trim().slice(0, 2000);
+            if (cleaned.length > 10) {
+                messages.push({
+                    text: cleaned,
+                    rawLength: msgContent.length,
+                    cleanedLength: cleaned.length,
+                });
+            }
+        }
+        // Skip list content (tool results)
+    }
+    return messages;
+}
+function findSessionFiles(baseDir, maxPerProject = 50) {
+    const files = [];
+    if (!existsSync(baseDir))
+        return files;
+    try {
+        const entries = readdirSync(baseDir);
+        for (const entry of entries) {
+            const entryPath = join(baseDir, entry);
+            try {
+                const stat = statSync(entryPath);
+                if (stat.isDirectory()) {
+                    // This is a project directory — look for JSONL files inside
+                    try {
+                        const projectFiles = readdirSync(entryPath)
+                            .filter((f) => f.endsWith(".jsonl"))
+                            .map((f) => join(entryPath, f))
+                            .filter((f) => {
+                            try {
+                                return statSync(f).size > 1000;
+                            }
+                            catch {
+                                return false;
+                            }
+                        })
+                            .sort((a, b) => {
+                            try {
+                                return statSync(b).mtimeMs - statSync(a).mtimeMs;
+                            }
+                            catch {
+                                return 0;
+                            }
+                        })
+                            .slice(0, maxPerProject);
+                        files.push(...projectFiles);
+                    }
+                    catch {
+                        // Skip unreadable project dirs
+                    }
+                }
+                else if (entry.endsWith(".jsonl") && stat.size > 1000) {
+                    files.push(entryPath);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        // Base dir not readable
+    }
+    return files;
+}
+function findCoworkSessions(maxSessions = 50) {
+    const coworkBase = join(homedir(), "Library", "Application Support", "Claude", "local-agent-mode-sessions");
+    if (!existsSync(coworkBase))
+        return [];
+    const files = [];
+    function walkDir(dir) {
+        try {
+            for (const entry of readdirSync(dir)) {
+                const fullPath = join(dir, entry);
+                try {
+                    const stat = statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        walkDir(fullPath);
+                    }
+                    else if (entry.endsWith(".jsonl") && stat.size > 1000) {
+                        files.push(fullPath);
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        catch {
+            // Skip unreadable dirs
+        }
+    }
+    walkDir(coworkBase);
+    return files
+        .sort((a, b) => {
+        try {
+            return statSync(b).mtimeMs - statSync(a).mtimeMs;
+        }
+        catch {
+            return 0;
+        }
+    })
+        .slice(0, maxSessions);
+}
+export function findAllSessions(maxSessions = 100) {
+    const claudeCodeBase = join(homedir(), ".claude", "projects");
+    const claudeCodeFiles = findSessionFiles(claudeCodeBase);
+    const coworkFiles = findCoworkSessions();
+    const allFiles = [...claudeCodeFiles, ...coworkFiles]
+        .sort((a, b) => {
+        try {
+            return statSync(b).mtimeMs - statSync(a).mtimeMs;
+        }
+        catch {
+            return 0;
+        }
+    })
+        .slice(0, maxSessions);
+    const sessions = [];
+    for (const filePath of allFiles) {
+        const messages = extractUserMessages(filePath);
+        if (messages.length === 0)
+            continue;
+        const sessionId = basename(filePath, ".jsonl");
+        const project = basename(filePath.includes("local-agent-mode") ? filePath : join(filePath, ".."));
+        sessions.push({
+            sessionId: sessionId.slice(0, 8),
+            project,
+            path: filePath,
+            messages,
+            fileSize: statSync(filePath).size,
+        });
+    }
+    return sessions;
+}

package/dist/core/profile.js

@@ -0,0 +1,254 @@
+/**
+ * Aggregate per-session classifications into a skill profile and assign archetype.
+ *
+ * The archetype system is DETERMINISTIC — no LLM call needed.
+ * Uses three axes derived from the artifact effect data in the AI Fluency Index:
+ *   Specification (Description): behaviors that INCREASE with polished artifacts
+ *   Evaluation (Discernment): behaviors that DECREASE with polished artifacts
+ *   Setup (Delegation): behaviors independent of artifact effect
+ *
+ * Research basis:
+ *   - Artifact effect: Anthropic AI Fluency Index (Feb 2026)
+ *   - Three-tier clustering: "Nested Skills in Labor Ecosystems" (Nature Human Behaviour, 2025)
+ *   - Parallel dimensions: AI literacy systematic review (PMC, 2024, 16 scales)
+ */
+import { BASELINES, BEHAVIOR_LABELS, AXES, } from "./classify.js";
+// ─── Axis behavior groupings ───────────────────────────────────────────────
+const SPEC_BEHAVIORS = AXES.Specification.behaviors;
+const EVAL_BEHAVIORS = AXES.Evaluation.behaviors;
+const SETUP_BEHAVIORS = AXES.Setup.behaviors;
+const SPEC_BASELINE = AXES.Specification.baseline;
+const EVAL_BASELINE = AXES.Evaluation.baseline;
+const SETUP_BASELINE = AXES.Setup.baseline;
+// ─── The 7 Archetypes ──────────────────────────────────────────────────────
+export const ARCHETYPES = {
+    polymath: {
+        name: "The Polymath",
+        tagline: "You shape the output AND hold it to account — the rarest combination.",
+        description: "You've developed fluency across both specification and evaluation — " +
+            "the two dimensions that most users specialize in, not combine. " +
+            "The data shows these skills are anti-correlated in practice (the artifact effect), " +
+            "which makes your balance genuinely unusual.",
+        superpower: "Adaptive fluency — you shift between shaping and scrutinizing as the moment demands",
+        growth_unlock: "Deepen your rarest axis — even polymaths have a frontier",
+        growth_quest: "In your next session, find the one moment where you'd normally accept output " +
+            "and instead push deeper — ask 'why this approach and not another?'",
+        target_archetype: null,
+        color: "#a08040",
+        accent: "#e8d8b0",
+        glyph: "polymath",
+    },
+    conductor: {
+        name: "The Conductor",
+        tagline: "You set the destination AND specify every detail of the journey.",
+        description: "You orchestrate Claude like an ensemble — clear goals upfront, " +
+            "then precise specifications for format, examples, and tone. " +
+            "You combine the Compass's direction with the Forgemaster's craft.",
+        superpower: "Full-spectrum direction — Claude performs at its peak because you brief both the what and the how",
+        growth_unlock: "Unlock The Polymath's edge — add evaluation to your orchestration",
+        growth_quest: "Next session, after Claude delivers what you specified, " +
+            "pick one claim and ask: 'How confident are you in this? What might be wrong?'",
+        target_archetype: "polymath",
+        color: "#8b3a62",
+        accent: "#d4a0b8",
+        glyph: "conductor",
+    },
+    architect: {
+        name: "The Architect",
+        tagline: "You design the collaboration AND inspect every load-bearing wall.",
+        description: "You combine strategic setup with critical evaluation — " +
+            "you set clear goals, discuss approach, and then scrutinize " +
+            "what Claude produces. You catch what others miss because " +
+            "you know what you were looking for.",
+        superpower: "Strategic scrutiny — your evaluation is targeted because your setup was intentional",
+        growth_unlock: "Unlock The Polymath's craft — add specification to your evaluation",
+        growth_quest: "Next session, try showing Claude an example of exactly what you want " +
+            "before you start evaluating what it gives you.",
+        target_archetype: "polymath",
+        color: "#5a6a7a",
+        accent: "#b0c0d0",
+        glyph: "architect",
+    },
+    forgemaster: {
+        name: "The Forgemaster",
+        tagline: "Every response from Claude is raw material — you shape it until it gleams.",
+        description: "You specify what you want with precision: examples of desired output, " +
+            "format requirements, tone preferences, audience awareness. " +
+            "You transform generic responses into exactly what you envisioned.",
+        superpower: "Output alchemy — you turn Claude's first draft into your final vision through pure craft",
+        growth_unlock: "Unlock The Conductor's vision — add strategic setup to your craft",
+        growth_quest: "Next session, before specifying details, try stating your overall goal " +
+            "and asking Claude to propose an approach first.",
+        target_archetype: "conductor",
+        color: "#b8860b",
+        accent: "#e8d4a8",
+        glyph: "forgemaster",
+    },
+    illuminator: {
+        name: "The Illuminator",
+        tagline: "You see what others skip — the gap, the assumption, the flaw in the logic.",
+        description: "You evaluate Claude's output critically: identifying missing context, " +
+            "questioning reasoning, verifying claims. In a world where polished AI output " +
+            "makes most users less critical (the artifact effect), you resist that pull.",
+        superpower: "Pattern recognition — you catch what Claude misses before it compounds",
+        growth_unlock: "Unlock The Architect's structure — add deliberate setup to your evaluation",
+        growth_quest: "Next session, try setting a clear goal and interaction mode before you start " +
+            "evaluating — give Claude the context to get closer on the first try.",
+        target_archetype: "architect",
+        color: "#3d8a5a",
+        accent: "#a8d4b8",
+        glyph: "illuminator",
+    },
+    compass: {
+        name: "The Compass",
+        tagline: "You always know where you're going — and trust Claude to find the best path.",
+        description: "You set up collaborations deliberately: clear goals, discussed approach, " +
+            "defined interaction style. You delegate effectively because you brief well. " +
+            "You don't micromanage the output — you set the destination and let Claude drive.",
+        superpower: "Strategic clarity — Claude always knows what you need before the first word is written",
+        growth_unlock: "Unlock The Conductor's precision — add output specifications to your direction",
+        growth_quest: "Next session, after stating your goal, try adding: 'Here's an example of " +
+            "what good output looks like' or 'Format this as...'",
+        target_archetype: "conductor",
+        color: "#4a7ba3",
+        accent: "#a3c4db",
+        glyph: "compass",
+    },
+    catalyst: {
+        name: "The Catalyst",
+        tagline: "You move at the speed of intuition — fast, iterative, unencumbered.",
+        description: "You work with Claude through pure momentum: ask, iterate, refine, ship. " +
+            "You don't over-specify or over-question — you trust the loop. " +
+            "This is a valid, powerful collaboration style, especially for rapid exploration.",
+        superpower: "Rapid transmutation — first drafts become final product through sheer iteration speed",
+        growth_unlock: "Unlock The Compass's direction — try stating your destination before launching",
+        growth_quest: "Next session, try opening with one sentence: 'My goal is [X] because [Y].' " +
+            "See how it changes what Claude gives you on the first try.",
+        target_archetype: "compass",
+        color: "#d4584a",
+        accent: "#e8a090",
+        glyph: "catalyst",
+    },
+};
+// ─── Deterministic archetype assignment ────────────────────────────────────
+export function determineArchetype(behaviors) {
+    function axisAvg(keys) {
+        const rates = keys.map((k) => behaviors[k]?.rate ?? 0);
+        return rates.reduce((a, b) => a + b, 0) / rates.length;
+    }
+    const spec = axisAvg(SPEC_BEHAVIORS);
+    const eval_ = axisAvg(EVAL_BEHAVIORS);
+    const setup = axisAvg(SETUP_BEHAVIORS);
+    const specHigh = spec > SPEC_BASELINE;
+    const evalHigh = eval_ > EVAL_BASELINE;
+    const setupHigh = setup > SETUP_BASELINE;
+    // Priority order: most specific combination first
+    if (specHigh && evalHigh)
+        return "polymath";
+    if (specHigh && setupHigh)
+        return "conductor";
+    if (evalHigh && setupHigh)
+        return "architect";
+    if (specHigh)
+        return "forgemaster";
+    if (evalHigh)
+        return "illuminator";
+    if (setupHigh)
+        return "compass";
+    return "catalyst";
+}
+// ─── Build profile ─────────────────────────────────────────────────────────
+export function buildProfile(classifications, previousProfile) {
+    const total = classifications.length;
+    // Compute per-behavior stats
+    const behaviors = {};
+    for (const key of Object.keys(BASELINES)) {
+        const presentCount = classifications.filter((c) => c.behaviors[key]?.present).length;
+        const rate = total > 0 ? presentCount / total : 0;
+        const baseline = BASELINES[key];
+        const evidence = [];
+        for (const c of classifications) {
+            const b = c.behaviors[key];
+            if (b?.present && b.evidence && b.evidence !== "none") {
+                evidence.push({
+                    text: b.evidence,
+                    session_id: c.sessionId,
+                    project: "",
+                });
+                if (evidence.length >= 3)
+                    break;
+            }
+        }
+        behaviors[key] = {
+            label: BEHAVIOR_LABELS[key],
+            rate: Math.round(rate * 1000) / 1000,
+            baseline,
+            above_baseline: rate > baseline,
+            present_count: presentCount,
+            total_sessions: total,
+            evidence,
+        };
+    }
+    // Compute axis/branch scores
+    const branches = {};
+    for (const [axisName, axisDef] of Object.entries(AXES)) {
+        const rates = axisDef.behaviors.map((k) => behaviors[k].rate);
+        const baselines = axisDef.behaviors.map((k) => BASELINES[k]);
+        const score = rates.reduce((a, b) => a + b, 0) / rates.length;
+        const baseline = baselines.reduce((a, b) => a + b, 0) / baselines.length;
+        branches[axisName] = {
+            score: Math.round(score * 1000) / 1000,
+            baseline: Math.round(baseline * 1000) / 1000,
+            above_baseline: score > baseline,
+            color: axisDef.color,
+            description: axisDef.description,
+            behaviors: axisDef.behaviors,
+        };
+    }
+    // Deterministic archetype assignment (no LLM call)
+    const archetypeKey = determineArchetype(behaviors);
+    const archetypeData = ARCHETYPES[archetypeKey];
+    function axisAvg(keys) {
+        const rates = keys.map((k) => behaviors[k]?.rate ?? 0);
+        return Math.round((rates.reduce((a, b) => a + b, 0) / rates.length) * 1000) / 1000;
+    }
+    const archetype = {
+        ...archetypeData,
+        key: archetypeKey,
+        axis_scores: {
+            specification: axisAvg(SPEC_BEHAVIORS),
+            evaluation: axisAvg(EVAL_BEHAVIORS),
+            setup: axisAvg(SETUP_BEHAVIORS),
+        },
+    };
+    // Growth edge: behavior with largest negative gap vs baseline
+    let growthEdgeKey = Object.keys(BASELINES)[0];
+    let worstGap = Infinity;
+    for (const key of Object.keys(BASELINES)) {
+        const gap = behaviors[key].rate - BASELINES[key];
+        if (gap < worstGap) {
+            worstGap = gap;
+            growthEdgeKey = key;
+        }
+    }
+    const profile = {
+        total_sessions: total,
+        behaviors,
+        branches,
+        archetype,
+        growth_edge: {
+            behavior: growthEdgeKey,
+            label: BEHAVIOR_LABELS[growthEdgeKey],
+            rate: behaviors[growthEdgeKey].rate,
+            baseline: BASELINES[growthEdgeKey],
+            gap: Math.round(worstGap * 1000) / 1000,
+        },
+        generated_at: new Date().toISOString(),
+    };
+    // Track progress from previous profile
+    if (previousProfile) {
+        profile.previous_archetype = previousProfile.archetype.key;
+        profile.previous_generated_at = previousProfile.generated_at;
+    }
+    return profile;
+}