@temet/cli 0.3.0 → 0.3.2

package/dist/lib/diagnostic-runner.js

@@ -0,0 +1,95 @@
+import { basename } from "node:path";
+import { createInterface } from "node:readline";
+import { resolveSessionPath } from "./path-resolver.js";
+import { trackAuditSnapshot } from "./audit-tracking.js";
+import { findSessionFiles, runAudit, } from "./session-audit.js";
+async function chooseSessionCandidate(candidates) {
+    if (!process.stdin.isTTY || candidates.length === 0)
+        return null;
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    process.stderr.write(`\n[temet] I found ${candidates.length} Claude Code projects with session history. Pick one to inspect.\n\n`);
+    candidates.slice(0, 9).forEach((candidate, index) => {
+        process.stderr.write(`  ${index + 1}. ${candidate.label}${index === 0 ? "  (most recent)" : ""}\n`);
+    });
+    process.stderr.write("\n");
+    return new Promise((resolve) => {
+        rl.question("[temet] Choose 1-9, or press Enter for the most recent project: ", (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            if (!trimmed) {
+                resolve(candidates[0] ?? null);
+                return;
+            }
+            const index = Number.parseInt(trimmed, 10) - 1;
+            if (!Number.isFinite(index) ||
+                index < 0 ||
+                index >= candidates.length) {
+                resolve(candidates[0] ?? null);
+                return;
+            }
+            resolve(candidates[index] ?? null);
+        });
+    });
+}
+export async function resolveDiagnostics(opts) {
+    const resolution = resolveSessionPath(opts.path || undefined, process.env);
+    if (!resolution.path) {
+        throw new Error("No Claude Code sessions found here. Run this command from a project folder, or use --path <session-dir>.");
+    }
+    let resolvedPath = resolution.path;
+    if (!opts.path &&
+        !opts.json &&
+        !opts.quiet &&
+        resolution.source === "recent" &&
+        resolution.candidates.length > 1) {
+        const selected = await chooseSessionCandidate(resolution.candidates);
+        resolvedPath = selected?.sessionDir ?? resolution.path;
+        const label = selected?.label ?? resolution.candidates[0]?.label;
+        if (label) {
+            process.stderr.write(`[temet] using ${label}\n`);
+        }
+    }
+    else {
+        const label = resolution.candidates[0]?.label;
+        if (label && resolution.source !== "explicit" && !opts.quiet) {
+            process.stderr.write(`[temet] using ${label}\n`);
+        }
+    }
+    const sessionFiles = findSessionFiles(resolvedPath);
+    if (sessionFiles.length === 0) {
+        throw new Error(`No .jsonl session files found in ${resolvedPath}.`);
+    }
+    if (!opts.quiet) {
+        process.stderr.write(`[temet] reading ${sessionFiles.length} saved session file(s)...\n`);
+    }
+    const result = await runAudit(sessionFiles);
+    let competencies = result.competencies;
+    let bilan;
+    if (opts.narrate && !opts.quiet) {
+        try {
+            const narratorModule = await import("./narrator-lite.js");
+            if (narratorModule.resolveAuth()) {
+                const narrated = await narratorModule.narrateCompetencies(competencies, result.combined, result.workflows, { model: opts.model || undefined });
+                competencies = narrated.competencies;
+                bilan = narrated.bilan || undefined;
+            }
+        }
+        catch {
+            // Keep deterministic fallback if narration fails.
+        }
+    }
+    let tracking;
+    if (opts.track) {
+        tracking = await trackAuditSnapshot(resolvedPath, result, competencies);
+    }
+    return {
+        resolvedPath,
+        result,
+        competencies,
+        bilan,
+        tracking,
+    };
+}
+export function defaultProjectLabel(resolvedPath) {
+    return basename(resolvedPath);
+}

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/menubar-installer.d.ts

@@ -0,0 +1,19 @@
+export declare const TEMET_BAR_APP_NAME = "Temet.app";
+export type MenubarInstallResult = {
+    appPath: string;
+    configPath: string;
+    hookInstalled: boolean;
+};
+export declare function getMenubarAppPath(): string;
+export declare function isMenubarInstalled(): boolean;
+export declare function getMenubarAssetPath(): string;
+export declare function installMenubar(options?: {
+    dryRun?: boolean;
+    ensureHook?: boolean;
+}): Promise<MenubarInstallResult>;
+export declare function uninstallMenubar(options?: {
+    dryRun?: boolean;
+}): Promise<{
+    appPath: string;
+    configPath: string;
+}>;

package/dist/lib/menubar-installer.js

@@ -0,0 +1,99 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { getSettingsPath, installHook, isHookInstalled, readSettings, resolveTemetBinary, writeSettings, } from "./hook-installer.js";
+import { getMenubarConfigPath, writeMenubarConfig } from "./menubar-state.js";
+const execFileAsync = promisify(execFile);
+export const TEMET_BAR_APP_NAME = "Temet.app";
+function findCliPackageRoot() {
+    let current = path.dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        const packageJson = path.join(current, "package.json");
+        if (existsSync(packageJson)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error("Could not resolve @temet/cli package root.");
+        }
+        current = parent;
+    }
+}
+export function getMenubarAppPath() {
+    return path.join(homedir(), "Applications", TEMET_BAR_APP_NAME);
+}
+export function isMenubarInstalled() {
+    return existsSync(getMenubarAppPath());
+}
+export function getMenubarAssetPath() {
+    return path.join(findCliPackageRoot(), "assets", "macos", "Temet.app.zip");
+}
+async function bestEffortClearQuarantine(appPath) {
+    try {
+        await execFileAsync("xattr", ["-d", "com.apple.quarantine", appPath]);
+    }
+    catch {
+        // Best effort only.
+    }
+}
+export async function installMenubar(options) {
+    if (process.platform !== "darwin") {
+        throw new Error("Temet is only available in the macOS menu bar.");
+    }
+    const assetPath = getMenubarAssetPath();
+    if (!existsSync(assetPath)) {
+        throw new Error(`Missing Temet.app.zip in ${assetPath}. Build and package the menu bar app first.`);
+    }
+    const binary = resolveTemetBinary();
+    if (!binary) {
+        throw new Error("Could not resolve the temet binary. Install @temet/cli globally first.");
+    }
+    const appPath = getMenubarAppPath();
+    const configPath = getMenubarConfigPath();
+    let hookInstalled = false;
+    if (options?.dryRun) {
+        return { appPath, configPath, hookInstalled: options.ensureHook === true };
+    }
+    await mkdir(path.dirname(appPath), { recursive: true });
+    await rm(appPath, { recursive: true, force: true });
+    await execFileAsync("unzip", ["-oq", assetPath, "-d", path.dirname(appPath)]);
+    await writeMenubarConfig(binary);
+    if (options?.ensureHook) {
+        const settingsPath = getSettingsPath();
+        const settings = readSettings(settingsPath);
+        if (!isHookInstalled(settings)) {
+            const updated = installHook(settings, binary);
+            writeSettings(settingsPath, updated);
+            hookInstalled = true;
+        }
+    }
+    await bestEffortClearQuarantine(appPath);
+    try {
+        await execFileAsync("open", [appPath]);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Temet was installed but macOS refused to open it automatically. Open ${appPath} manually. Details: ${message}`);
+    }
+    return { appPath, configPath, hookInstalled };
+}
+export async function uninstallMenubar(options) {
+    const appPath = getMenubarAppPath();
+    const configPath = getMenubarConfigPath();
+    if (options?.dryRun) {
+        return { appPath, configPath };
+    }
+    try {
+        await execFileAsync("pkill", ["-f", "Temet.app"]);
+    }
+    catch {
+        // App may not be running.
+    }
+    await rm(appPath, { recursive: true, force: true });
+    await rm(configPath, { force: true });
+    return { appPath, configPath };
+}

package/dist/lib/menubar-state.d.ts

@@ -0,0 +1,78 @@
+import { type TrackingResult } from "./audit-tracking.js";
+import type { AuditResult } from "./session-audit.js";
+import type { CompetencyEntry, ProficiencyLevel } from "./types.js";
+export type MenubarSuperpower = {
+    title: string;
+    level: ProficiencyLevel;
+    evidenceCount: number;
+};
+export type MenubarWatch = {
+    title: string;
+    body: string;
+};
+export type CurrentFocusStatus = "active" | "improving" | "missed" | "completed" | "replaced";
+export type CurrentFocusCheck = "followed" | "not_followed" | "insufficient_signal";
+export type MenubarCurrentFocus = {
+    title: string;
+    reason: string;
+    startedAt: string;
+    durationDays: number;
+    status: CurrentFocusStatus;
+    lastCheck: CurrentFocusCheck;
+    streak: number;
+};
+export type MenubarMetrics = {
+    sessions: number;
+    prompts: number;
+    toolCalls: number;
+    workflows: number;
+};
+export type MenubarProgress = {
+    summary: string;
+    reinforced: string;
+    watch: string;
+    new: string;
+    next: string;
+    notificationTitle: string;
+    notificationBody: string;
+};
+export type TemetMenubarState = {
+    version: 1;
+    projectKey: string;
+    projectLabel: string;
+    createdAt: string;
+    trackingInstalled: boolean;
+    metrics: MenubarMetrics;
+    dna: string;
+    superpower: MenubarSuperpower;
+    watch: MenubarWatch;
+    progress: MenubarProgress;
+    recentChange: string;
+    currentFocus: MenubarCurrentFocus;
+    lastReportPath: string | null;
+    sourcePath: string;
+};
+export type MenubarConfig = {
+    version: 1;
+    temetBinary: string;
+};
+type BuildMenubarStateInput = {
+    sourcePath: string;
+    result: Pick<AuditResult, "sessionCount" | "promptCount" | "messageCount" | "toolCallCount" | "workflowCount" | "workflows" | "signals">;
+    competencies: CompetencyEntry[];
+    bilan?: string;
+    tracking?: TrackingResult;
+    trackingInstalled: boolean;
+    lastReportPath?: string | null;
+    previousState?: TemetMenubarState | null;
+};
+export declare function getMenubarStatePath(): string;
+export declare function getMenubarConfigPath(): string;
+export declare function buildMenubarState(input: BuildMenubarStateInput): TemetMenubarState;
+export declare function loadMenubarState(): Promise<TemetMenubarState | null>;
+export declare function writeMenubarState(input: BuildMenubarStateInput): Promise<TemetMenubarState>;
+export declare function loadMenubarConfig(): Promise<MenubarConfig | null>;
+export declare function writeMenubarConfig(temetBinary: string): Promise<MenubarConfig>;
+export declare function isMenubarConfigPresent(): boolean;
+export declare function resolveLastReportPath(projectLabel: string): Promise<string | null>;
+export {};

package/dist/lib/menubar-state.js

@@ -0,0 +1,275 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { buildAuditSnapshot, } from "./audit-tracking.js";
+import { buildSkillAuditReport, } from "./profile-report.js";
+import { findLatestReportPath } from "./report-writer.js";
+const PROFICIENCY_SCORE = {
+    novice: 1,
+    advanced_beginner: 2,
+    competent: 3,
+    proficient: 4,
+    expert: 5,
+};
+function getTemetRoot() {
+    return path.join(homedir(), ".temet");
+}
+function getMenubarRoot() {
+    return path.join(getTemetRoot(), "menubar");
+}
+export function getMenubarStatePath() {
+    return path.join(getMenubarRoot(), "latest.json");
+}
+export function getMenubarConfigPath() {
+    return path.join(getMenubarRoot(), "config.json");
+}
+function evidenceCount(entry) {
+    return (entry.evidence.examples.length +
+        entry.evidence.decisionCriteria.length +
+        entry.evidence.antiPatterns.length +
+        entry.evidence.mentorAdvice.length);
+}
+function pickTopCompetency(competencies) {
+    return [...competencies].sort((a, b) => {
+        const scoreA = PROFICIENCY_SCORE[a.proficiencyLevel] * 10 + evidenceCount(a);
+        const scoreB = PROFICIENCY_SCORE[b.proficiencyLevel] * 10 + evidenceCount(b);
+        if (scoreA !== scoreB)
+            return scoreB - scoreA;
+        return a.name.localeCompare(b.name);
+    })[0];
+}
+function firstSentence(value) {
+    const trimmed = value.replace(/\s+/g, " ").trim();
+    if (!trimmed)
+        return "";
+    const match = trimmed.match(/^(.+?[.!?])(?:\s|$)/);
+    return (match?.[1] ?? trimmed).trim();
+}
+function sanitizeLine(value, fallback) {
+    const trimmed = value.replace(/\s+/g, " ").trim();
+    return trimmed.length > 0 ? trimmed : fallback;
+}
+function trimPreview(value, maxLength) {
+    const normalized = sanitizeLine(value, "");
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, maxLength).trimEnd()}...`;
+}
+function humanizeChange(change) {
+    switch (change.type) {
+        case "new_skill":
+            return change.title.replace(/^New skill surfaced:\s*/i, "New skill: ");
+        case "new_workflow":
+            return "A new workflow signal surfaced";
+        case "level_up":
+            return change.title.replace(/\s*moved up$/i, " is strengthening");
+        case "level_down":
+            return change.title.replace(/\s*moved down$/i, " needs attention");
+        case "baseline":
+            return "Tracking baseline created";
+    }
+}
+function selectCurrentFocusTemplate(watch) {
+    switch (watch.title) {
+        case "Feature sprawl":
+            return {
+                title: "Validate demand before adding product surface",
+                reason: firstSentence(watch.body),
+                durationDays: 7,
+            };
+        case "Git hygiene under pressure":
+            return {
+                title: "Tighten git hygiene before pushing",
+                reason: firstSentence(watch.body),
+                durationDays: 7,
+            };
+        case "Technical detours":
+            return {
+                title: "Stop exploration once product value flattens",
+                reason: firstSentence(watch.body),
+                durationDays: 7,
+            };
+        case "Coordination drag":
+            return {
+                title: "Name the next decision before expanding scope",
+                reason: firstSentence(watch.body),
+                durationDays: 7,
+            };
+        default:
+            return {
+                title: `Address ${watch.title.toLowerCase()}`,
+                reason: firstSentence(watch.body),
+                durationDays: 7,
+            };
+    }
+}
+function evaluateCurrentFocus(watch, createdAt, previousState) {
+    const template = selectCurrentFocusTemplate(watch);
+    if (!previousState) {
+        return {
+            ...template,
+            startedAt: createdAt,
+            status: "active",
+            lastCheck: "insufficient_signal",
+            streak: 0,
+        };
+    }
+    if (previousState.currentFocus.title !== template.title) {
+        return {
+            ...template,
+            startedAt: createdAt,
+            status: "active",
+            lastCheck: "insufficient_signal",
+            streak: 0,
+        };
+    }
+    return {
+        ...template,
+        startedAt: previousState.currentFocus.startedAt,
+        status: "active",
+        lastCheck: "insufficient_signal",
+        streak: 0,
+    };
+}
+function buildProgress(currentFocus, watch, changes, previousState) {
+    const meaningfulChanges = changes.filter((change) => change.type !== "baseline");
+    const firstMeaningful = meaningfulChanges[0];
+    const isNewFocus = previousState?.currentFocus.title != null &&
+        previousState.currentFocus.title !== currentFocus.title;
+    const humanizedSignal = firstMeaningful
+        ? humanizeChange(firstMeaningful)
+        : null;
+    const reinforced = currentFocus.lastCheck === "followed"
+        ? currentFocus.title
+        : (humanizedSignal ?? currentFocus.title);
+    const watchLine = currentFocus.lastCheck === "not_followed"
+        ? "Last session drifted away from this focus."
+        : firstSentence(watch.body);
+    const newSignal = humanizedSignal ?? "No new signal surfaced yet";
+    const next = "Open plan to review the operating adjustment.";
+    let summary = "Set today. Temet will start checking this focus after your next tracked session.";
+    if (isNewFocus) {
+        summary = `New focus: ${currentFocus.title}.`;
+    }
+    else if (currentFocus.lastCheck === "not_followed") {
+        summary = `Last session pulled away from ${currentFocus.title.toLowerCase()}.`;
+    }
+    else if (currentFocus.lastCheck === "followed") {
+        summary = `${currentFocus.title} showed up in your last session.`;
+    }
+    else if (previousState?.currentFocus.title === currentFocus.title) {
+        summary =
+            "Still active. Temet is calibrating this focus from your next tracked sessions.";
+    }
+    const notificationBody = [
+        summary,
+        watchLine,
+        firstMeaningful ? `New signal: ${newSignal}.` : null,
+    ]
+        .filter(Boolean)
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+    return {
+        summary,
+        reinforced,
+        watch: watchLine,
+        new: newSignal,
+        next,
+        notificationTitle: "Temet update",
+        notificationBody,
+    };
+}
+export function buildMenubarState(input) {
+    const snapshot = input.tracking?.current ??
+        buildAuditSnapshot(input.sourcePath, input.result, input.competencies);
+    const report = buildSkillAuditReport(input.result, input.competencies, input.tracking);
+    const watchSection = report.blindSpots[0] ??
+        {
+            title: "No watch item computed yet",
+            body: "Run more tracked audits to surface a stable watch item.",
+        };
+    const topCompetency = pickTopCompetency(input.competencies);
+    const watch = {
+        title: watchSection.title,
+        body: sanitizeLine(watchSection.body, "No watch item computed yet."),
+    };
+    const currentFocus = evaluateCurrentFocus(watch, snapshot.createdAt, input.previousState?.projectKey === snapshot.projectKey
+        ? input.previousState
+        : null);
+    const progress = buildProgress(currentFocus, watch, input.tracking?.changes ?? [], input.previousState?.projectKey === snapshot.projectKey
+        ? input.previousState
+        : null);
+    const latestMeaningfulChange = input.tracking?.changes.find((change) => change.type !== "baseline");
+    return {
+        version: 1,
+        projectKey: snapshot.projectKey,
+        projectLabel: snapshot.projectLabel,
+        createdAt: snapshot.createdAt,
+        trackingInstalled: input.trackingInstalled,
+        metrics: {
+            sessions: snapshot.sessions,
+            prompts: input.result.promptCount,
+            toolCalls: snapshot.toolCalls,
+            workflows: input.result.workflowCount,
+        },
+        dna: sanitizeLine(input.bilan?.trim() || report.professionalDna, "No professional DNA available yet."),
+        superpower: {
+            title: topCompetency?.name ??
+                report.tacitSkills[0]?.title ??
+                "No superpower yet",
+            level: topCompetency?.proficiencyLevel ?? "novice",
+            evidenceCount: topCompetency ? evidenceCount(topCompetency) : 0,
+        },
+        watch,
+        progress,
+        recentChange: latestMeaningfulChange
+            ? humanizeChange(latestMeaningfulChange)
+            : "No new signal surfaced yet.",
+        currentFocus,
+        lastReportPath: input.lastReportPath ?? null,
+        sourcePath: snapshot.sourcePath,
+    };
+}
+export async function loadMenubarState() {
+    try {
+        const raw = await readFile(getMenubarStatePath(), "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed?.version === 1 ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeMenubarState(input) {
+    const state = buildMenubarState(input);
+    await mkdir(getMenubarRoot(), { recursive: true });
+    await writeFile(getMenubarStatePath(), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+    return state;
+}
+export async function loadMenubarConfig() {
+    try {
+        const raw = await readFile(getMenubarConfigPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed?.version === 1 && parsed.temetBinary ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeMenubarConfig(temetBinary) {
+    await mkdir(getMenubarRoot(), { recursive: true });
+    const payload = {
+        version: 1,
+        temetBinary,
+    };
+    await writeFile(getMenubarConfigPath(), `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    return payload;
+}
+export function isMenubarConfigPresent() {
+    return existsSync(getMenubarConfigPath());
+}
+export async function resolveLastReportPath(projectLabel) {
+    return findLatestReportPath(projectLabel);
+}