@temet/cli 0.2.0 → 0.3.1

package/dist/lib/narrator-lite.js

@@ -0,0 +1,231 @@
+// ---------- Excerpt Selection ----------
+const CORRECTION_RX = [
+    /\bnon\b/i,
+    /\bpas comme [cç]a\b/i,
+    /\bc'est pas\b/i,
+    /\bplut[oô]t\b/i,
+    /\brevert\b/i,
+    /\bwrong\b/i,
+    /\bnot like that\b/i,
+    /\bundo\b/i,
+    /\bactually\b/i,
+    /\binstead\b/i,
+];
+const DECISION_RX = [
+    /je pr[eé]f[eè]re/i,
+    /toujours\s/i,
+    /jamais\s/i,
+    /il faut/i,
+    /I prefer/i,
+    /always\s/i,
+    /never\s/i,
+    /we should/i,
+    /make sure to/i,
+];
+function getTextContent(msg) {
+    return msg.content
+        .filter((b) => b.type === "text")
+        .map((b) => b.text)
+        .join("\n");
+}
+function scoreMessage(msg) {
+    const text = getTextContent(msg);
+    if (!text)
+        return 0;
+    let score = 0;
+    for (const rx of CORRECTION_RX) {
+        if (rx.test(text)) {
+            score += 3;
+            break;
+        }
+    }
+    for (const rx of DECISION_RX) {
+        if (rx.test(text)) {
+            score += 2;
+            break;
+        }
+    }
+    if (text.length > 500)
+        score += 1;
+    return score;
+}
+function selectExcerpts(combined, max = 10) {
+    return combined.messages
+        .filter((m) => m.role === "user")
+        .map((m) => ({ msg: m, score: scoreMessage(m) }))
+        .filter((s) => s.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, max)
+        .map((s) => ({
+        text: getTextContent(s.msg).slice(0, 300),
+        role: s.msg.role,
+    }));
+}
+// ---------- Prompt ----------
+function buildPrompt(raw, excerpts, workflows) {
+    const competencyList = raw
+        .map((c) => `- ${c.name} [${c.proficiencyLevel}] (${c.category}): ${c.description}`)
+        .join("\n");
+    const excerptList = excerpts
+        .map((e, i) => `${i + 1}. "${e.text}"`)
+        .join("\n");
+    const workflowList = workflows.length > 0
+        ? workflows
+            .map((w) => `- ${w.description}: ${w.sequence.join(" → ")} (${w.occurrences}x across ${w.sessions} sessions)`)
+            .join("\n")
+        : "None detected.";
+    return `You are analyzing a developer's coding sessions to produce a professional competency profile.
+
+## Raw Competencies (from heuristic analysis)
+${competencyList}
+
+## User Excerpts (from sessions)
+${excerptList}
+
+## Detected Workflows
+${workflowList}
+
+## Instructions
+
+Return a JSON object with exactly two keys:
+
+1. "competencies": an array of enriched competency objects. For each raw competency above, produce an object with these fields:
+   - "id": same as raw
+   - "name": same as raw
+   - "category": same as raw
+   - "proficiencyLevel": same as raw (adjust only if evidence strongly supports a different level)
+   - "description": a 1-2 sentence narrative description (not the raw heuristic output)
+   - "evidence": object with:
+     - "examples": array of 2-4 concrete examples drawn from the excerpts/workflows
+     - "decisionCriteria": array of 1-3 decision principles the developer follows
+     - "antiPatterns": array of 1-2 things the developer avoids
+     - "mentorAdvice": array of 1-2 insights about how this developer works
+   - "prerequisites": array of related skills needed (0-3)
+   - "synergies": array of complementary skills (0-3)
+
+2. "bilan": a markdown narrative summary (300-600 words) covering:
+   - Developer profile overview
+   - Key strengths and surprising patterns
+   - Workflow patterns and methodology
+   - Progression areas and recommendations
+
+Keep descriptions professional but human. Ground everything in the evidence provided.
+Return ONLY valid JSON, no markdown fences.`;
+}
+// ---------- Response Parser ----------
+function ensureStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((v) => typeof v === "string");
+}
+function parseResponse(text, fallback) {
+    try {
+        const cleaned = text
+            .replace(/^```json?\s*/m, "")
+            .replace(/```\s*$/m, "")
+            .trim();
+        const parsed = JSON.parse(cleaned);
+        if (!parsed.competencies ||
+            !Array.isArray(parsed.competencies) ||
+            !parsed.bilan ||
+            typeof parsed.bilan !== "string") {
+            return { competencies: fallback, bilan: "" };
+        }
+        const validated = [];
+        for (const c of parsed.competencies) {
+            if (!c ||
+                typeof c !== "object" ||
+                !c.id ||
+                !c.name ||
+                !c.category ||
+                !c.proficiencyLevel)
+                continue;
+            const ev = c.evidence && typeof c.evidence === "object" ? c.evidence : {};
+            validated.push({
+                ...c,
+                description: typeof c.description === "string" ? c.description : "",
+                evidence: {
+                    examples: ensureStringArray(ev.examples),
+                    decisionCriteria: ensureStringArray(ev.decisionCriteria),
+                    antiPatterns: ensureStringArray(ev.antiPatterns),
+                    mentorAdvice: ensureStringArray(ev.mentorAdvice),
+                },
+                prerequisites: ensureStringArray(c.prerequisites),
+                synergies: ensureStringArray(c.synergies),
+            });
+        }
+        if (validated.length === 0)
+            return { competencies: fallback, bilan: parsed.bilan ?? "" };
+        return { competencies: validated, bilan: parsed.bilan };
+    }
+    catch {
+        return { competencies: fallback, bilan: "" };
+    }
+}
+export function resolveAuth() {
+    const claudeToken = process.env.CLAUDE_AUTH_TOKEN;
+    const claudeBase = process.env.CLAUDE_API_BASE_URL;
+    // Primary: Claude bearer proxy (same path as the app's provider chain)
+    if (claudeToken) {
+        const base = claudeBase ?? "https://api.anthropic.com";
+        const url = base.includes("/v1/messages") ? base : `${base}/v1/messages`;
+        return {
+            url,
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${claudeToken}`,
+                "anthropic-version": "2023-06-01",
+            },
+            source: "CLAUDE_AUTH_TOKEN",
+        };
+    }
+    // Fallback: direct Anthropic API key
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (apiKey) {
+        return {
+            url: "https://api.anthropic.com/v1/messages",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            source: "ANTHROPIC_API_KEY",
+        };
+    }
+    return null;
+}
+// ---------- API Call ----------
+export async function narrateCompetencies(raw, combined, workflows, options) {
+    const auth = resolveAuth();
+    if (!auth) {
+        console.error("[temet] --narrate requires model access. Set ANTHROPIC_API_KEY or CLAUDE_AUTH_TOKEN.");
+        return { competencies: raw, bilan: "" };
+    }
+    const model = options?.model ?? "claude-haiku-4-5-20251001";
+    const excerpts = selectExcerpts(combined);
+    const prompt = buildPrompt(raw, excerpts, workflows);
+    console.error(`[temet] narrator using ${auth.source}`);
+    try {
+        const resp = await fetch(auth.url, {
+            method: "POST",
+            headers: auth.headers,
+            body: JSON.stringify({
+                model,
+                max_tokens: 4096,
+                messages: [{ role: "user", content: prompt }],
+            }),
+        });
+        if (!resp.ok) {
+            const body = await resp.text();
+            console.error(`[temet] narrator API error (${resp.status}): ${body}`);
+            return { competencies: raw, bilan: "" };
+        }
+        const data = (await resp.json());
+        const text = data.content?.find((b) => b.type === "text")?.text ?? "";
+        return parseResponse(text, raw);
+    }
+    catch (err) {
+        console.error("[temet] narrator call failed:", err);
+        return { competencies: raw, bilan: "" };
+    }
+}

package/dist/lib/notifier.d.ts

@@ -0,0 +1,9 @@
+import type { AuditChange } from "./audit-tracking.js";
+export type NotificationPayload = {
+    title: string;
+    body: string;
+};
+/** Build the notification text from audit changes. Returns null if nothing to notify. */
+export declare function formatNotification(changes: AuditChange[], projectLabel: string): NotificationPayload | null;
+/** Send a native OS notification. Fire-and-forget. */
+export declare function sendNotification(payload: NotificationPayload): Promise<void>;

package/dist/lib/notifier.js

@@ -0,0 +1,57 @@
+import { execFile } from "node:child_process";
+import { appendFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+/** Build the notification text from audit changes. Returns null if nothing to notify. */
+export function formatNotification(changes, projectLabel) {
+    if (changes.length === 0)
+        return null;
+    // Baseline
+    if (changes.length === 1 && changes[0].type === "baseline") {
+        const skillCount = changes[0].detail.match(/(\d+)/)?.[1] ?? "0";
+        return {
+            title: "Temet",
+            body: `Tracking started for ${projectLabel}`,
+        };
+    }
+    const meaningful = changes.filter((c) => c.type !== "baseline");
+    if (meaningful.length === 0)
+        return null;
+    const first = meaningful[0];
+    const body = meaningful.length === 1
+        ? first.title
+        : `${first.title} and ${meaningful.length - 1} more`;
+    return { title: "Temet", body };
+}
+/** Send a native OS notification. Fire-and-forget. */
+export async function sendNotification(payload) {
+    const { title, body } = payload;
+    if (process.platform === "darwin") {
+        return new Promise((resolve, reject) => {
+            const escaped = body.replace(/"/g, '\\"');
+            const script = `display notification "${escaped}" with title "${title.replace(/"/g, '\\"')}"`;
+            execFile("osascript", ["-e", script], (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    if (process.platform === "linux") {
+        return new Promise((resolve, reject) => {
+            execFile("notify-send", [title, body], (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    // Fallback: log to file
+    const logDir = path.join(homedir(), ".temet");
+    await mkdir(logDir, { recursive: true });
+    const logPath = path.join(logDir, "notifications.log");
+    const line = `[${new Date().toISOString()}] ${title}: ${body}\n`;
+    await appendFile(logPath, line, "utf8");
+}

package/dist/lib/path-resolver.d.ts

@@ -0,0 +1,39 @@
+export type SessionCandidate = {
+    sessionDir: string;
+    label: string;
+    updatedAtMs: number;
+};
+export type SessionResolution = {
+    path: string | null;
+    source: "explicit" | "env" | "stdin" | "cwd" | "recent" | "none";
+    candidates: SessionCandidate[];
+};
+type ResolveSessionPathOptions = {
+    cwd?: string;
+    claudeRoot?: string;
+    hookInput?: {
+        cwd?: string;
+    } | null;
+};
+/** Convert an absolute project directory to the Claude Code session directory slug. */
+export declare function cwdToSessionDir(cwd: string): string;
+export declare function humanizeSessionDir(sessionDir: string): string;
+export declare function findClaudeProjectCandidates(claudeRoot?: string): SessionCandidate[];
+/**
+ * Try to read the JSON stdin from a Claude Code hook (non-blocking).
+ * Only safe to call when we know stdin has finite piped data (hook context).
+ * Consumes stdin — call at most once per process.
+ */
+export declare function readHookStdin(): {
+    cwd?: string;
+} | null;
+/**
+ * Resolve the session path by priority:
+ * 1. Explicit --path value
+ * 2. $CLAUDE_PROJECT_DIR env var
+ * 3. stdin JSON cwd (hook context)
+ * 4. process.cwd()
+ * 5. most recent valid Claude project
+ */
+export declare function resolveSessionPath(explicit: string | undefined, env: NodeJS.ProcessEnv, options?: ResolveSessionPathOptions): SessionResolution;
+export {};

package/dist/lib/path-resolver.js

@@ -0,0 +1,152 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+const DEFAULT_CLAUDE_ROOT = path.join(homedir(), ".claude", "projects");
+/** Convert an absolute project directory to the Claude Code session directory slug. */
+export function cwdToSessionDir(cwd) {
+    const slug = path.resolve(cwd).replace(/\//g, "-");
+    return path.join(DEFAULT_CLAUDE_ROOT, slug);
+}
+export function humanizeSessionDir(sessionDir) {
+    const slug = path.basename(sessionDir);
+    if (!slug)
+        return sessionDir;
+    if (slug.startsWith("-")) {
+        return slug.replace(/-/g, "/");
+    }
+    return slug;
+}
+function hasJsonlSessions(dir) {
+    try {
+        for (const entry of readdirSync(dir)) {
+            const full = path.join(dir, entry);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                if (hasJsonlSessions(full))
+                    return true;
+                continue;
+            }
+            if (stat.isFile() && entry.endsWith(".jsonl"))
+                return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+function candidateFromSessionDir(sessionDir) {
+    if (!existsSync(sessionDir) || !hasJsonlSessions(sessionDir))
+        return null;
+    let updatedAtMs = 0;
+    try {
+        updatedAtMs = statSync(sessionDir).mtimeMs;
+    }
+    catch {
+        updatedAtMs = 0;
+    }
+    return {
+        sessionDir,
+        label: humanizeSessionDir(sessionDir),
+        updatedAtMs,
+    };
+}
+export function findClaudeProjectCandidates(claudeRoot = DEFAULT_CLAUDE_ROOT) {
+    try {
+        return readdirSync(claudeRoot)
+            .map((entry) => path.join(claudeRoot, entry))
+            .filter((full) => {
+            try {
+                return statSync(full).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })
+            .map(candidateFromSessionDir)
+            .filter((candidate) => candidate !== null)
+            .sort((a, b) => b.updatedAtMs - a.updatedAtMs);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Try to read the JSON stdin from a Claude Code hook (non-blocking).
+ * Only safe to call when we know stdin has finite piped data (hook context).
+ * Consumes stdin — call at most once per process.
+ */
+export function readHookStdin() {
+    try {
+        if (process.stdin.isTTY)
+            return null;
+        if (!process.env.CLAUDECODE)
+            return null;
+        const data = readFileSync(0, "utf8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the session path by priority:
+ * 1. Explicit --path value
+ * 2. $CLAUDE_PROJECT_DIR env var
+ * 3. stdin JSON cwd (hook context)
+ * 4. process.cwd()
+ * 5. most recent valid Claude project
+ */
+export function resolveSessionPath(explicit, env, options = {}) {
+    if (explicit) {
+        return {
+            path: explicit,
+            source: "explicit",
+            candidates: [],
+        };
+    }
+    const cwd = options.cwd ?? process.cwd();
+    const claudeRoot = options.claudeRoot ?? DEFAULT_CLAUDE_ROOT;
+    const fromEnv = env.CLAUDE_PROJECT_DIR
+        ? candidateFromSessionDir(path.join(claudeRoot, path.resolve(env.CLAUDE_PROJECT_DIR).replace(/\//g, "-")))
+        : null;
+    if (fromEnv) {
+        return {
+            path: fromEnv.sessionDir,
+            source: "env",
+            candidates: [fromEnv],
+        };
+    }
+    const hookInput = options.hookInput ?? readHookStdin();
+    const fromStdin = hookInput?.cwd
+        ? candidateFromSessionDir(path.join(claudeRoot, path.resolve(hookInput.cwd).replace(/\//g, "-")))
+        : null;
+    if (fromStdin) {
+        return {
+            path: fromStdin.sessionDir,
+            source: "stdin",
+            candidates: [fromStdin],
+        };
+    }
+    const fromCwd = candidateFromSessionDir(path.join(claudeRoot, path.resolve(cwd).replace(/\//g, "-")));
+    if (fromCwd) {
+        return {
+            path: fromCwd.sessionDir,
+            source: "cwd",
+            candidates: [fromCwd],
+        };
+    }
+    const candidates = findClaudeProjectCandidates(claudeRoot);
+    if (candidates.length > 0) {
+        return {
+            path: candidates[0].sessionDir,
+            source: "recent",
+            candidates,
+        };
+    }
+    return {
+        path: null,
+        source: "none",
+        candidates: [],
+    };
+}

package/dist/lib/profile-report.d.ts

@@ -0,0 +1,18 @@
+import type { TrackingResult } from "./audit-tracking.js";
+import type { AuditResult } from "./session-audit.js";
+import type { CompetencyEntry } from "./types.js";
+export type NarrativeSection = {
+    title: string;
+    tagline?: string;
+    body: string;
+};
+export type SkillAuditReport = {
+    title: string;
+    subtitle: string;
+    tacitSkills: NarrativeSection[];
+    blindSpots: NarrativeSection[];
+    professionalDna: string;
+    metaSkill: NarrativeSection;
+    meaningfulChanges: string[];
+};
+export declare function buildSkillAuditReport(result: Pick<AuditResult, "sessionCount" | "promptCount" | "toolCallCount" | "workflowCount" | "signals">, competencies: CompetencyEntry[], tracking?: Pick<TrackingResult, "changes">): SkillAuditReport;

package/dist/lib/profile-report.js

@@ -0,0 +1,148 @@
+import { extractEditorialEvidence, fallbackEditorialSummary, isCommoditySkillName, matchEditorialSkill, } from "./editorial-taxonomy.js";
+const PROFICIENCY_SCORE = {
+    expert: 5,
+    proficient: 4,
+    competent: 3,
+    advanced_beginner: 2,
+    novice: 1,
+};
+function scoreCompetency(entry) {
+    const evidenceCount = entry.evidence.examples.length +
+        entry.evidence.decisionCriteria.length +
+        entry.evidence.antiPatterns.length +
+        entry.evidence.mentorAdvice.length;
+    return PROFICIENCY_SCORE[entry.proficiencyLevel] * 10 + evidenceCount;
+}
+function pickTacitSkills(competencies) {
+    const sorted = [...competencies].sort((a, b) => scoreCompetency(b) - scoreCompetency(a));
+    const usedTitles = new Set();
+    const sections = [];
+    const presetMatches = sorted.filter((entry) => matchEditorialSkill(entry));
+    const fallbackCandidates = sorted.filter((entry) => !matchEditorialSkill(entry) && !isCommoditySkillName(entry.name));
+    for (const entry of presetMatches) {
+        const preset = matchEditorialSkill(entry);
+        const title = preset?.title ?? entry.name;
+        if (usedTitles.has(title))
+            continue;
+        usedTitles.add(title);
+        const evidence = extractEditorialEvidence(entry);
+        sections.push({
+            title,
+            tagline: preset?.tagline,
+            body: preset
+                ? preset.render(entry, evidence)
+                : fallbackEditorialSummary(entry),
+        });
+        if (sections.length >= 10)
+            break;
+    }
+    if (sections.length < 6) {
+        for (const entry of fallbackCandidates) {
+            const preset = matchEditorialSkill(entry);
+            const title = preset?.title ?? entry.name;
+            if (usedTitles.has(title))
+                continue;
+            usedTitles.add(title);
+            const evidence = extractEditorialEvidence(entry);
+            sections.push({
+                title,
+                tagline: preset?.tagline,
+                body: preset
+                    ? preset.render(entry, evidence)
+                    : fallbackEditorialSummary(entry),
+            });
+            if (sections.length >= 8)
+                break;
+        }
+    }
+    return sections;
+}
+function hasSkill(competencies, pattern) {
+    return competencies.some((entry) => pattern.test(entry.name.toLowerCase()));
+}
+function buildBlindSpots(result, competencies) {
+    const blindSpots = [];
+    if (result.workflowCount >= 80) {
+        blindSpots.push({
+            title: "Feature sprawl",
+            body: "You can generate momentum faster than you stabilize it. When the number of patterns and directions keeps climbing, the risk is not lack of output. It is losing the discipline to decide what deserves to become a finished path.",
+        });
+    }
+    if (hasSkill(competencies, /version control/) ||
+        result.signals.some((signal) => /version control/i.test(signal.skill))) {
+        blindSpots.push({
+            title: "Git hygiene under pressure",
+            body: "Your work suggests strong version-control awareness, but also the kind of environment where branch, commit, and release pressure can still create avoidable mess. This is usually a systems problem, not a knowledge problem.",
+        });
+    }
+    if (hasSkill(competencies, /research|architecture|code comprehension|refactoring/)) {
+        blindSpots.push({
+            title: "Technical detours",
+            body: "You are capable of going deep, which is a strength until exploration keeps running after product value has flattened. The risk is not bad engineering. It is staying fascinated one loop too long.",
+        });
+    }
+    const fallback = [
+        {
+            title: "Feature sprawl",
+            body: "You move quickly once a direction looks promising. The risk is not inactivity. It is letting the number of live possibilities grow faster than the number of finished outcomes.",
+        },
+        {
+            title: "Coordination drag",
+            body: "As your systems become more capable, the hidden cost shifts toward alignment, naming, and decision clarity. Work can stay technically correct while still becoming harder to coordinate.",
+        },
+        {
+            title: "Technical detours",
+            body: "Deep exploration is one of your strengths, but it can keep producing value long after the product question should have ended the loop. Good curiosity still needs a stopping rule.",
+        },
+    ];
+    for (const item of fallback) {
+        if (blindSpots.some((existing) => existing.title === item.title))
+            continue;
+        blindSpots.push(item);
+        if (blindSpots.length >= 3)
+            break;
+    }
+    return blindSpots.slice(0, 3);
+}
+function buildProfessionalDna(tacitSkills, competencies) {
+    const anchors = tacitSkills.slice(0, 3).map((skill) => skill.title);
+    const stacks = competencies
+        .filter((entry) => /cloudflare|react|api|type system|component|security|shell/i.test(entry.name))
+        .slice(0, 4)
+        .map((entry) => entry.name);
+    const stackLine = stacks.length > 0
+        ? `The technical signal clusters around ${stacks.join(", ")}.`
+        : "The technical signal clusters around architecture, implementation judgment, and repeated execution patterns.";
+    return `This profile points to someone who turns ambiguity into execution. The strongest signals are ${anchors.join(", ")}, which together describe a person who reads systems carefully, imposes structure early, and keeps moving through short feedback loops instead of relying on one big heroic pass. ${stackLine} The distinctive advantage is not one isolated skill, but the ability to convert messy work into something legible, directional, and reusable.`;
+}
+function buildMetaSkill(tacitSkills) {
+    const titles = tacitSkills.map((skill) => skill.title.toLowerCase());
+    if (titles.some((title) => title.includes("plan-first")) &&
+        titles.some((title) => title.includes("codebase archaeology"))) {
+        return {
+            title: "Turning ambiguity into executable systems",
+            body: "Across the report, the deepest pattern is not just building or reviewing. It is repeatedly taking vague, shifting work and turning it into a system that can be understood, executed, and improved. That is the skill underneath the other skills.",
+        };
+    }
+    return {
+        title: "Building feedback loops around real work",
+        body: "The common thread is not any one tool or framework. It is the habit of turning real work into a loop: observe, judge, change, test, and run again. That is what makes the rest of the profile coherent.",
+    };
+}
+function buildMeaningfulChanges(tracking) {
+    if (!tracking || tracking.changes.length === 0)
+        return [];
+    return tracking.changes.map((change) => `${change.title} — ${change.detail}`);
+}
+export function buildSkillAuditReport(result, competencies, tracking) {
+    const tacitSkills = pickTacitSkills(competencies);
+    return {
+        title: `TACIT SKILL EXTRACTION — ${result.promptCount.toLocaleString("en-US")} prompts analyzed`,
+        subtitle: `${result.sessionCount.toLocaleString("en-US")} sessions · ${result.toolCallCount.toLocaleString("en-US")} tool calls · ${result.workflowCount.toLocaleString("en-US")} workflow patterns. This is a deterministic Temet reading of the skills, habits, and judgment patterns that show up repeatedly in your real AI work.`,
+        tacitSkills,
+        blindSpots: buildBlindSpots(result, competencies),
+        professionalDna: buildProfessionalDna(tacitSkills, competencies),
+        metaSkill: buildMetaSkill(tacitSkills),
+        meaningfulChanges: buildMeaningfulChanges(tracking),
+    };
+}

package/dist/lib/report-writer.d.ts

@@ -0,0 +1,7 @@
+import type { AuditResult } from "./session-audit.js";
+import type { TrackingResult } from "./audit-tracking.js";
+import type { CompetencyEntry } from "./types.js";
+export declare function buildAuditTextReport(result: Pick<AuditResult, "sessionCount" | "promptCount" | "toolCallCount" | "signals" | "workflowCount" | "workflows">, competencies: CompetencyEntry[], bilan?: string, tracking?: Pick<TrackingResult, "changes" | "current">): string;
+export declare function buildReportPath(projectLabel: string, now?: Date): string;
+export declare function saveAuditTextReport(projectLabel: string, content: string, now?: Date): Promise<string>;
+export declare function openReportFile(filePath: string, platform?: NodeJS.Platform): Promise<void>;