@temet/cli 0.2.0 → 0.3.1

package/dist/index.js

@@ -4,25 +4,44 @@ import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 import { promisify } from "node:util";
+import { buildAuditCliOptions, parseFlagBag, readOptionalString, } from "./lib/cli-args.js";
 const execFileAsync = promisify(execFile);
 const DEFAULT_RELAY_URL = "https://temet-relay.ramponneau.workers.dev/mcp";
 const DEFAULT_SERVER_NAME = "temet";
 const DEFAULT_PROTOCOL_APP_NAME = "Temet Handler";
 const LINUX_DESKTOP_ENTRY = "temet-handler.desktop";
 const LINUX_HANDLER_SCRIPT = "temet-protocol-handler";
-const HELP = `Temet CLI
+const HELP = `Temet CLI — discover the skills you already demonstrate in AI work
 
-Usage:
-\ttemet connect --address <16hex> --token <token> [--config-path <path>] [--relay-url <url>] [--name temet] [--dry-run]
-\ttemet connect-url --url "temet://connect?address=<16hex>&token=<token>&relay=<url>&name=temet" [--config-path <path>] [--name temet] [--relay-url <url>] [--dry-run]
-\ttemet install-handler [--dry-run]
-\ttemet uninstall-handler [--dry-run]
+Commands:
+\ttemet audit [--path <session-dir>]        Analyze local sessions, surface skills and workflows
+\ttemet install-hook                        Auto-audit after every Claude Code session
+\ttemet uninstall-hook                      Remove the SessionEnd hook
+\ttemet connect --address <hex> --token <t> Connect your MCP client to your Temet card
+\ttemet install-handler                     Register temet:// protocol handler
+
+Audit options:
+\t--path <dir>     Directory containing .jsonl session files (auto-detected if omitted)
+\t--track          Save a local snapshot and compare against the previous audit
+\t--open-report    Explicitly save and open the text report (opened by default unless --json or --quiet)
+\t--json           Output structured JSON instead of terminal display
+\t--quiet          Suppress all output (for background hooks)
+\t--notify         Send an OS notification on skill changes (used with --track)
+\t--publish        Publish results to your Temet card (requires confirmation)
+\t--yes, -y        Skip publish confirmation (for scripts/CI)
+
+Advanced:
+\t--narrate        Enrich results with an LLM (requires model access: ANTHROPIC_API_KEY or CLAUDE_AUTH_TOKEN)
+\t--model <id>     Model to use for narration (default: claude-haiku-4-5-20251001)
 
 Examples:
-\ttemet connect --address a3f8c2d19f0b7e41 --token <token>
-\ttemet connect-url --url "temet://connect?address=a3f8c2d19f0b7e41&token=<token>&relay=https%3A%2F%2Ftemet-relay.ramponneau.workers.dev%2Fmcp"
-\tpnpm dlx @temet/cli install-handler
-\tpnpm dlx @temet/cli connect-url --url "temet://connect?address=a3f8c2d19f0b7e41&token=<token>"
+\ttemet audit                                            Auto-detect sessions from cwd
+\ttemet audit                                            Open the text report by default
+\ttemet audit --path ~/.claude/projects/my-project
+\ttemet audit --path ~/.claude/projects/my-project --track
+\ttemet audit --path ~/.claude/projects/my-project --open-report
+\ttemet audit --path ~/.claude/projects/my-project --json
+\ttemet install-hook                                     Background audit on session end
 `;
 function printHelp(exitCode = 0) {
     console.log(HELP);
@@ -38,36 +57,6 @@ function normalizeAddress(raw) {
     }
     return address;
 }
-function parseFlagBag(args) {
-    const flags = new Map();
-    const positionals = [];
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg.startsWith("--")) {
-            positionals.push(arg);
-            continue;
-        }
-        if (arg === "--dry-run") {
-            flags.set("dry-run", true);
-            continue;
-        }
-        const key = arg.slice(2);
-        const value = args[i + 1];
-        if (!value || value.startsWith("--")) {
-            throw new Error(`Missing value for --${key}`);
-        }
-        flags.set(key, value);
-        i += 1;
-    }
-    return { flags, positionals };
-}
-function readOptionalString(flags, key) {
-    const value = flags.get(key);
-    if (typeof value !== "string")
-        return null;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
 function parseConnectOptions(flags) {
     const address = normalizeAddress(String(flags.get("address") ?? ""));
     const token = String(flags.get("token") ?? "").trim();
@@ -156,6 +145,12 @@ function parseArgs(argv) {
     const [command, ...rest] = argv;
     const { flags, positionals } = parseFlagBag(rest);
     const dryRun = Boolean(flags.get("dry-run"));
+    if (command === "audit") {
+        return {
+            command,
+            options: buildAuditCliOptions(flags, process.env),
+        };
+    }
     if (command === "connect") {
         return {
             command,
@@ -171,6 +166,9 @@ function parseArgs(argv) {
     if (command === "install-handler" || command === "uninstall-handler") {
         return { command, dryRun };
     }
+    if (command === "install-hook" || command === "uninstall-hook") {
+        return { command, dryRun };
+    }
     console.error(`Unknown command: ${command}`);
     printHelp(1);
 }
@@ -491,10 +489,57 @@ async function uninstallProtocolHandler(dryRun) {
 }
 async function run() {
     const parsed = parseArgs(process.argv.slice(2));
+    if (parsed.command === "audit") {
+        const { runAuditCommand } = await import("./audit.js");
+        await runAuditCommand(parsed.options);
+        return;
+    }
     if (parsed.command === "connect" || parsed.command === "connect-url") {
         await runWriteFlow(parsed.command, parsed.options);
         return;
     }
+    if (parsed.command === "install-hook") {
+        const { resolveTemetBinary, readSettings, writeSettings, isHookInstalled, installHook, getSettingsPath, } = await import("./lib/hook-installer.js");
+        const settingsPath = getSettingsPath();
+        const settings = readSettings(settingsPath);
+        if (isHookInstalled(settings)) {
+            console.log("[temet] Hook already installed.");
+            return;
+        }
+        const binary = resolveTemetBinary();
+        if (!binary) {
+            console.error("[temet] Could not resolve temet binary. Install @temet/cli globally first: npm i -g @temet/cli");
+            process.exit(1);
+        }
+        if (parsed.dryRun) {
+            console.log(`[temet] dry-run: binary resolved to: ${binary}`);
+            console.log(`[temet] dry-run: would write to ${settingsPath}`);
+            return;
+        }
+        const updated = installHook(settings, binary);
+        writeSettings(settingsPath, updated);
+        console.log(`[temet] Resolved binary: ${binary}`);
+        console.log(`[temet] SessionEnd hook installed in ${settingsPath}`);
+        console.log("[temet] Restart Claude Code for the hook to take effect.");
+        return;
+    }
+    if (parsed.command === "uninstall-hook") {
+        const { readSettings, writeSettings, isHookInstalled, uninstallHook, getSettingsPath, } = await import("./lib/hook-installer.js");
+        const settingsPath = getSettingsPath();
+        const settings = readSettings(settingsPath);
+        if (!isHookInstalled(settings)) {
+            console.log("[temet] No hook installed.");
+            return;
+        }
+        if (parsed.dryRun) {
+            console.log(`[temet] dry-run: would remove hook from ${settingsPath}`);
+            return;
+        }
+        const updated = uninstallHook(settings);
+        writeSettings(settingsPath, updated);
+        console.log("[temet] SessionEnd hook removed.");
+        return;
+    }
     if (parsed.command === "install-handler") {
         await installProtocolHandler(parsed.dryRun);
         console.log("[temet] next: click a Quick connect button in Temet.");

package/dist/lib/analysis-types.d.ts

@@ -0,0 +1,7 @@
+import type { SessionMessage, ToolCall } from "./session-parser.js";
+export type CombinedStats = {
+    messages: SessionMessage[];
+    toolCalls: ToolCall[];
+    filesTouched: string[];
+    allToolCallsBySession: ToolCall[][];
+};

package/dist/lib/analysis-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/audit-tracking.d.ts

@@ -0,0 +1,55 @@
+import type { AuditResult } from "./session-audit.js";
+import type { CompetencyEntry, ProficiencyLevel } from "./types.js";
+export type AuditSkillSnapshot = {
+    name: string;
+    category: string;
+    proficiencyLevel: ProficiencyLevel;
+    evidenceCount: number;
+};
+export type AuditWorkflowSnapshot = {
+    description: string;
+    sequence: string[];
+    occurrences: number;
+    sessions: number;
+    confidence: number;
+};
+export type AuditSnapshot = {
+    version: 1;
+    createdAt: string;
+    projectKey: string;
+    projectLabel: string;
+    sourcePath: string;
+    sessions: number;
+    messages: number;
+    toolCalls: number;
+    skills: AuditSkillSnapshot[];
+    workflows: AuditWorkflowSnapshot[];
+};
+export type AuditChange = {
+    type: "baseline";
+    title: string;
+    detail: string;
+} | {
+    type: "new_skill" | "level_up" | "level_down" | "new_workflow";
+    title: string;
+    detail: string;
+};
+export type TrackingResult = {
+    previous: AuditSnapshot | null;
+    current: AuditSnapshot;
+    changes: AuditChange[];
+    latestPath: string;
+    historyPath: string;
+    skipped: boolean;
+};
+export declare function buildProjectKey(sourcePath: string): string;
+export declare function buildAuditSnapshot(sourcePath: string, result: Pick<AuditResult, "sessionCount" | "messageCount" | "toolCallCount" | "workflows">, competencies: CompetencyEntry[]): AuditSnapshot;
+export declare function loadLatestSnapshot(sourcePath: string): Promise<AuditSnapshot | null>;
+export declare function saveAuditSnapshot(snapshot: AuditSnapshot): Promise<{
+    latestPath: string;
+    historyPath: string;
+}>;
+export declare function diffAuditSnapshots(previous: AuditSnapshot | null, current: AuditSnapshot): AuditChange[];
+/** Check if two snapshots have identical skills and workflows (ignoring timestamps/counts). */
+export declare function snapshotsEqual(a: AuditSnapshot, b: AuditSnapshot): boolean;
+export declare function trackAuditSnapshot(sourcePath: string, result: Pick<AuditResult, "sessionCount" | "messageCount" | "toolCallCount" | "workflows">, competencies: CompetencyEntry[]): Promise<TrackingResult>;

package/dist/lib/audit-tracking.js

@@ -0,0 +1,185 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+const PROFICIENCY_ORDER = {
+    novice: 0,
+    advanced_beginner: 1,
+    competent: 2,
+    proficient: 3,
+    expert: 4,
+};
+function normalizeName(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function evidenceCount(entry) {
+    return (entry.evidence.examples.length +
+        entry.evidence.decisionCriteria.length +
+        entry.evidence.antiPatterns.length +
+        entry.evidence.mentorAdvice.length);
+}
+export function buildProjectKey(sourcePath) {
+    return createHash("sha256")
+        .update(path.resolve(sourcePath))
+        .digest("hex")
+        .slice(0, 12);
+}
+function buildProjectLabel(sourcePath) {
+    const resolved = path.resolve(sourcePath);
+    const base = path.basename(resolved);
+    return base || resolved;
+}
+export function buildAuditSnapshot(sourcePath, result, competencies) {
+    return {
+        version: 1,
+        createdAt: new Date().toISOString(),
+        projectKey: buildProjectKey(sourcePath),
+        projectLabel: buildProjectLabel(sourcePath),
+        sourcePath: path.resolve(sourcePath),
+        sessions: result.sessionCount,
+        messages: result.messageCount,
+        toolCalls: result.toolCallCount,
+        skills: competencies
+            .map((entry) => ({
+            name: entry.name,
+            category: entry.category,
+            proficiencyLevel: entry.proficiencyLevel,
+            evidenceCount: evidenceCount(entry),
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name)),
+        workflows: result.workflows
+            .map((workflow) => ({
+            description: workflow.description,
+            sequence: workflow.sequence,
+            occurrences: workflow.occurrences,
+            sessions: workflow.sessions,
+            confidence: workflow.confidence,
+        }))
+            .sort((a, b) => a.description.localeCompare(b.description)),
+    };
+}
+function getTrackingPaths(projectKey) {
+    const root = path.join(homedir(), ".temet", "audits", projectKey);
+    return {
+        root,
+        latest: path.join(root, "latest.json"),
+        historyDir: path.join(root, "history"),
+    };
+}
+export async function loadLatestSnapshot(sourcePath) {
+    const { latest } = getTrackingPaths(buildProjectKey(sourcePath));
+    try {
+        const raw = await readFile(latest, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed?.version !== 1)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveAuditSnapshot(snapshot) {
+    const paths = getTrackingPaths(snapshot.projectKey);
+    await mkdir(paths.historyDir, { recursive: true });
+    const historyPath = path.join(paths.historyDir, `${snapshot.createdAt.replaceAll(":", "-")}.json`);
+    const payload = JSON.stringify(snapshot, null, 2);
+    await writeFile(paths.latest, payload, "utf8");
+    await writeFile(historyPath, payload, "utf8");
+    return { latestPath: paths.latest, historyPath };
+}
+export function diffAuditSnapshots(previous, current) {
+    if (!previous) {
+        return [
+            {
+                type: "baseline",
+                title: "Tracking baseline created",
+                detail: `Saved the first audit snapshot for ${current.projectLabel}.`,
+            },
+        ];
+    }
+    const changes = [];
+    const previousSkills = new Map(previous.skills.map((skill) => [normalizeName(skill.name), skill]));
+    const currentSkills = new Map(current.skills.map((skill) => [normalizeName(skill.name), skill]));
+    for (const [key, skill] of currentSkills) {
+        const before = previousSkills.get(key);
+        if (!before) {
+            if (PROFICIENCY_ORDER[skill.proficiencyLevel] >=
+                PROFICIENCY_ORDER.competent ||
+                skill.evidenceCount >= 2) {
+                changes.push({
+                    type: "new_skill",
+                    title: `New skill surfaced: ${skill.name}`,
+                    detail: `${skill.proficiencyLevel.replace("_", " ")} with ${skill.evidenceCount} evidence item(s).`,
+                });
+            }
+            continue;
+        }
+        const beforeLevel = PROFICIENCY_ORDER[before.proficiencyLevel];
+        const currentLevel = PROFICIENCY_ORDER[skill.proficiencyLevel];
+        if (currentLevel > beforeLevel) {
+            changes.push({
+                type: "level_up",
+                title: `${skill.name} moved up`,
+                detail: `${before.proficiencyLevel.replace("_", " ")} → ${skill.proficiencyLevel.replace("_", " ")}`,
+            });
+        }
+        else if (currentLevel < beforeLevel) {
+            changes.push({
+                type: "level_down",
+                title: `${skill.name} moved down`,
+                detail: `${before.proficiencyLevel.replace("_", " ")} → ${skill.proficiencyLevel.replace("_", " ")}`,
+            });
+        }
+    }
+    const previousWorkflows = new Set(previous.workflows.map((workflow) => normalizeName(workflow.description)));
+    for (const workflow of current.workflows) {
+        const key = normalizeName(workflow.description);
+        if (!previousWorkflows.has(key)) {
+            changes.push({
+                type: "new_workflow",
+                title: `New repeated pattern: ${workflow.description}`,
+                detail: `${workflow.occurrences} occurrences across ${workflow.sessions} sessions.`,
+            });
+        }
+    }
+    const order = {
+        baseline: 0,
+        level_up: 1,
+        new_skill: 2,
+        new_workflow: 3,
+        level_down: 4,
+    };
+    return changes.sort((a, b) => order[a.type] - order[b.type]).slice(0, 8);
+}
+/** Check if two snapshots have identical skills and workflows (ignoring timestamps/counts). */
+export function snapshotsEqual(a, b) {
+    return (JSON.stringify(a.skills) === JSON.stringify(b.skills) &&
+        JSON.stringify(a.workflows) === JSON.stringify(b.workflows));
+}
+export async function trackAuditSnapshot(sourcePath, result, competencies) {
+    const previous = await loadLatestSnapshot(sourcePath);
+    const current = buildAuditSnapshot(sourcePath, result, competencies);
+    // No-op guard: skip save if skills and workflows are identical
+    if (previous && snapshotsEqual(previous, current)) {
+        const paths = getTrackingPaths(current.projectKey);
+        return {
+            previous,
+            current,
+            changes: [],
+            latestPath: paths.latest,
+            historyPath: "",
+            skipped: true,
+        };
+    }
+    const changes = diffAuditSnapshots(previous, current);
+    const { latestPath, historyPath } = await saveAuditSnapshot(current);
+    return {
+        previous,
+        current,
+        changes,
+        latestPath,
+        historyPath,
+        skipped: false,
+    };
+}

package/dist/lib/cli-args.d.ts

@@ -0,0 +1,22 @@
+export type FlagValue = string | boolean;
+export type AuditCliOptions = {
+    path: string;
+    track: boolean;
+    narrate: boolean;
+    openReport: boolean;
+    json: boolean;
+    quiet: boolean;
+    notify: boolean;
+    publish: boolean;
+    yes: boolean;
+    model: string;
+    address: string;
+    token: string;
+    relayUrl: string;
+};
+export declare function parseFlagBag(args: string[]): {
+    flags: Map<string, FlagValue>;
+    positionals: string[];
+};
+export declare function readOptionalString(flags: Map<string, FlagValue>, key: string): string | null;
+export declare function buildAuditCliOptions(flags: Map<string, FlagValue>, env: NodeJS.ProcessEnv): AuditCliOptions;

package/dist/lib/cli-args.js

@@ -0,0 +1,65 @@
+export function parseFlagBag(args) {
+    const flags = new Map();
+    const positionals = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "-y") {
+            flags.set("yes", true);
+            continue;
+        }
+        if (!arg.startsWith("--")) {
+            positionals.push(arg);
+            continue;
+        }
+        if (arg === "--dry-run" ||
+            arg === "--track" ||
+            arg === "--narrate" ||
+            arg === "--open-report" ||
+            arg === "--json" ||
+            arg === "--quiet" ||
+            arg === "--notify" ||
+            arg === "--publish" ||
+            arg === "--yes") {
+            flags.set(arg.slice(2), true);
+            continue;
+        }
+        const key = arg.slice(2);
+        const value = args[i + 1];
+        if (!value || value.startsWith("--")) {
+            throw new Error(`Missing value for --${key}`);
+        }
+        flags.set(key, value);
+        i += 1;
+    }
+    return { flags, positionals };
+}
+export function readOptionalString(flags, key) {
+    const value = flags.get(key);
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export function buildAuditCliOptions(flags, env) {
+    const pathVal = readOptionalString(flags, "path") ?? "";
+    const json = Boolean(flags.get("json"));
+    const quiet = Boolean(flags.get("quiet"));
+    const explicitOpenReport = Boolean(flags.get("open-report"));
+    return {
+        path: pathVal,
+        track: Boolean(flags.get("track")),
+        narrate: Boolean(flags.get("narrate")),
+        openReport: explicitOpenReport || (!json && !quiet),
+        json,
+        quiet,
+        notify: Boolean(flags.get("notify")),
+        publish: Boolean(flags.get("publish")),
+        yes: Boolean(flags.get("yes")),
+        model: readOptionalString(flags, "model") ?? "",
+        address: readOptionalString(flags, "address") ?? env.TEMET_ADDRESS ?? "",
+        token: readOptionalString(flags, "token") ?? env.TEMET_TOKEN ?? "",
+        relayUrl: readOptionalString(flags, "relay-url") ??
+            env.RELAY_URL ??
+            "https://temet-relay.ramponneau.workers.dev",
+    };
+}

package/dist/lib/editorial-taxonomy.d.ts

@@ -0,0 +1,17 @@
+import type { CompetencyEntry } from "./types.js";
+type EditorialEvidence = {
+    examples: string[];
+    decisionCriteria: string[];
+    antiPatterns: string[];
+};
+type EditorialSkillPreset = {
+    title: string;
+    tagline?: string;
+    match: RegExp[];
+    render: (entry: CompetencyEntry, evidence: EditorialEvidence) => string;
+};
+export declare function extractEditorialEvidence(entry: CompetencyEntry): EditorialEvidence;
+export declare function isCommoditySkillName(name: string): boolean;
+export declare function fallbackEditorialSummary(entry: CompetencyEntry): string;
+export declare function matchEditorialSkill(entry: CompetencyEntry): EditorialSkillPreset | null;
+export {};

package/dist/lib/editorial-taxonomy.js

@@ -0,0 +1,91 @@
+const COMMODITY_PATTERNS = [
+    /\btypescript\b/i,
+    /\bjavascript\b/i,
+    /\bnext\.?js\b/i,
+    /\breact\b/i,
+    /\bapi routes?\b/i,
+    /\bshell scripting\b/i,
+    /\bcommand-line\b/i,
+    /\bterminal fluency\b/i,
+    /\bcodebase navigation\b/i,
+];
+function firstOrFallback(values, fallback) {
+    return values.find(Boolean) ?? fallback;
+}
+export function extractEditorialEvidence(entry) {
+    return {
+        examples: entry.evidence.examples.slice(0, 2),
+        decisionCriteria: entry.evidence.decisionCriteria.slice(0, 2),
+        antiPatterns: entry.evidence.antiPatterns.slice(0, 2),
+    };
+}
+export function isCommoditySkillName(name) {
+    return COMMODITY_PATTERNS.some((pattern) => pattern.test(name));
+}
+export function fallbackEditorialSummary(entry) {
+    const evidence = extractEditorialEvidence(entry);
+    const example = firstOrFallback(evidence.examples, `The signal behind ${entry.name} appears repeatedly in your sessions.`);
+    const decision = evidence.decisionCriteria[0]
+        ? `You also make decisions that reinforce it: ${evidence.decisionCriteria[0]}`
+        : "It is not just a topic you touch once. It shows up as a repeated working habit.";
+    return `${example} ${decision}`;
+}
+const EDITORIAL_SKILL_PRESETS = [
+    {
+        title: "Plan-First Discipline",
+        tagline: "You force structure before execution",
+        match: [/spec-driven/i, /implementation planning/i],
+        render: (_entry, evidence) => `${firstOrFallback(evidence.examples, "You repeatedly create structure before touching implementation.")} ${firstOrFallback(evidence.decisionCriteria, "You work as if planning, execution, and documentation should stay tied together, not happen in separate worlds.")}`,
+    },
+    {
+        title: "Codebase Archaeology",
+        tagline: "You read systems before changing them",
+        match: [/deep code comprehension/i, /before change/i],
+        render: (_entry, evidence) => `${firstOrFallback(evidence.examples, "You spend time reading the existing system before making changes.")} ${firstOrFallback(evidence.antiPatterns, "You do not treat the codebase like a blank canvas. You reconstruct its history and constraints first.")}`,
+    },
+    {
+        title: "Precision Refactoring",
+        tagline: "You change moving systems without losing the thread",
+        match: [/precise refactoring/i, /complex dependencies/i],
+        render: (_entry, evidence) => `${firstOrFallback(evidence.examples, "You refactor with unusually tight control over moving parts.")} ${firstOrFallback(evidence.decisionCriteria, "The signal is less about rewriting fast and more about changing a system without breaking its shape.")}`,
+    },
+    {
+        title: "Feedback-Loop Delivery",
+        tagline: "You drive work through short correction cycles",
+        match: [/feedback loops?/i, /test-driven delivery/i],
+        render: (_entry, evidence) => `${firstOrFallback(evidence.examples, "You move through short loops of change, test, and correction instead of one large pass.")} ${firstOrFallback(evidence.antiPatterns, "What matters here is not speed alone. It is your willingness to keep the loop tight until the output holds.")}`,
+    },
+    {
+        title: "Competitive Intelligence",
+        tagline: "You learn by comparing what already exists",
+        match: [/competitive intelligence/i, /research/i],
+        render: (_entry, evidence) => `${firstOrFallback(evidence.examples, "You repeatedly study adjacent tools, projects, and implementations before deciding what to adopt.")} ${firstOrFallback(evidence.decisionCriteria, "This is less trend-following than a disciplined habit of using outside reference points to sharpen your own decisions.")}`,
+    },
+    {
+        title: "Product Taste",
+        tagline: "You notice what feels right before it is fully rationalized",
+        match: [/product taste/i, /ux/i, /visual/i],
+        render: (_entry, evidence) => `${firstOrFallback(evidence.examples, "You repeatedly intervene on presentation, feel, and quality before those issues become formal design tickets.")} ${firstOrFallback(evidence.antiPatterns, "The pattern suggests judgment about what makes a product feel coherent, not just whether it technically works.")}`,
+    },
+    {
+        title: "Change-Risk Judgment",
+        tagline: "You treat risky changes as decisions, not just edits",
+        match: [/version control judgment/i, /risky changes/i, /security-aware/i],
+        render: (_entry, evidence) => `${firstOrFallback(evidence.antiPatterns, "You repeatedly catch where a change could introduce avoidable risk.")} ${firstOrFallback(evidence.decisionCriteria, "The signal here is judgment under uncertainty: knowing when a change should be slowed down, isolated, or validated more carefully.")}`,
+    },
+    {
+        title: "Contract Rigor",
+        tagline: "You care about the shape of systems at their boundaries",
+        match: [/contract rigor/i, /api boundary/i, /schema/i],
+        render: (_entry, evidence) => `${firstOrFallback(evidence.examples, "You repeatedly tighten interfaces, contracts, and the places where systems meet.")} ${firstOrFallback(evidence.decisionCriteria, "You seem to care less about local implementation cleverness than about whether the edges stay understandable and stable.")}`,
+    },
+];
+export function matchEditorialSkill(entry) {
+    const haystack = `${entry.name} ${entry.description}`.toLowerCase();
+    for (const preset of EDITORIAL_SKILL_PRESETS) {
+        if (preset.match.some((pattern) => pattern.test(haystack))) {
+            return preset;
+        }
+    }
+    return null;
+}

package/dist/lib/heuristics.d.ts

@@ -0,0 +1,15 @@
+import type { SessionStats } from "./session-parser.js";
+export type Signal = {
+    type: string;
+    skill: string;
+    confidence: number;
+    evidence: string;
+    category?: string;
+};
+export declare function extractCorrectionPatterns(stats: SessionStats): Signal[];
+export declare function extractToolFrequency(stats: SessionStats): Signal[];
+export declare function extractDecisionLanguage(stats: SessionStats): Signal[];
+export declare function extractDomainClusters(stats: SessionStats): Signal[];
+export declare function extractPromptStructure(stats: SessionStats): Signal[];
+export declare const ALL_EXTRACTORS: readonly [typeof extractCorrectionPatterns, typeof extractToolFrequency, typeof extractDecisionLanguage, typeof extractDomainClusters, typeof extractPromptStructure];
+export declare function extractAllSignals(stats: SessionStats): Signal[];