@temet/cli 0.3.1 → 0.3.2

package/assets/macos/README.md

@@ -0,0 +1,8 @@
+TemetBar packaged app assets live here.
+
+Expected artifact for `temet install-menubar`:
+
+- `TemetBar.app.zip`
+
+This artifact is produced from `packages/menubar-macos/` by the packaging
+script described in `SPEC_29`.

package/dist/audit.js

@@ -1,11 +1,14 @@
 /**
  * temet audit — analyze your coding sessions, surface your real skills.
  */
-import { basename } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
 import { clearLine, createInterface, cursorTo } from "node:readline";
 import { findSessionFiles, runAudit, } from "./lib/session-audit.js";
 import { resolveSessionPath, } from "./lib/path-resolver.js";
 import { trackAuditSnapshot, } from "./lib/audit-tracking.js";
+import { loadMenubarState, resolveLastReportPath, writeMenubarState, } from "./lib/menubar-state.js";
 export function buildAuditJsonOutput(result, competencies, bilan, tracking) {
     return {
         sessions: result.sessionCount,
@@ -273,10 +276,11 @@ function printPretty(result, competencies, bilan, tracking) {
     console.log(`${dim("─".repeat(44), process.stdout)}`);
     console.log(`${BOLD}Next${RESET}`);
     if (!tracking) {
-        console.log(`  ${DIM}temet audit --path <dir> --track${RESET}       Save a baseline and track changes`);
+        console.log(`  ${DIM}temet audit --path <dir> --track${RESET}       Save a baseline and track changes over time`);
     }
-    console.log(`  ${DIM}temet audit --path <dir> --json${RESET}        Export as JSON`);
-    console.log(`  ${DIM}temet audit --path <dir> --publish${RESET}     Publish to your Temet card`);
+    console.log(`  ${DIM}temet traces${RESET}                          See the proof behind this reading`);
+    console.log(`  ${DIM}temet plan${RESET}                            Turn this audit into a focused next-step plan`);
+    console.log(`  ${DIM}temet audit --path <dir> --publish${RESET}     Publish this audit to your Temet card`);
     console.log("");
     console.log(`${ok("Audit complete:", process.stdout)} ${formatCount(competencies.length)} skills surfaced from ${formatCount(result.sessionCount)} sessions`);
     if (tracking) {
@@ -284,7 +288,58 @@ function printPretty(result, competencies, bilan, tracking) {
     }
     console.log("");
 }
+// ---------- Hook decline persistence ----------
+const PREFS_PATH = join(homedir(), ".temet", "preferences.json");
+function readPrefs() {
+    try {
+        return JSON.parse(readFileSync(PREFS_PATH, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writePrefs(prefs) {
+    mkdirSync(join(homedir(), ".temet"), { recursive: true });
+    writeFileSync(PREFS_PATH, JSON.stringify(prefs, null, "\t") + "\n", "utf8");
+}
+function hasDeclinedHook() {
+    return readPrefs().hookDeclined === true;
+}
+function saveHookDeclined() {
+    writePrefs({ ...readPrefs(), hookDeclined: true });
+}
+function isMacOs() {
+    return process.platform === "darwin";
+}
+async function readHookInstalledSafe() {
+    try {
+        const hookModule = await import("./lib/hook-installer.js");
+        return hookModule.isHookInstalled(hookModule.readSettings(hookModule.getSettingsPath()));
+    }
+    catch {
+        return false;
+    }
+}
 // ---------- Confirmation ----------
+async function askYesNo(question, defaultYes, hintOverride) {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    const hint = hintOverride ??
+        (defaultYes
+            ? "Press Enter to continue, or type no to skip:"
+            : "Type yes to continue, or press Enter to cancel:");
+    return new Promise((resolve) => {
+        rl.question(`\n${BOLD}${question}${RESET}\n${dim(hint, process.stderr)} `, (answer) => {
+            rl.close();
+            const trimmed = answer.trim().toLowerCase();
+            if (trimmed === "")
+                resolve(defaultYes);
+            else
+                resolve(trimmed === "y" || trimmed === "yes");
+        });
+    });
+}
 async function confirmPublish(competencyCount, address) {
     // Non-interactive (piped stdin) → refuse without --yes
     if (!process.stdin.isTTY) {
@@ -293,9 +348,10 @@ async function confirmPublish(competencyCount, address) {
     }
     const rl = createInterface({ input: process.stdin, output: process.stderr });
     return new Promise((resolve) => {
-        rl.question(`\n${BOLD}Publish ${competencyCount} competencies to card ${address}?${RESET} [y/N] `, (answer) => {
+        rl.question(`\n${BOLD}Publish ${competencyCount} competencies to card ${address}?${RESET}\n${dim("Type yes to publish, or press Enter to cancel:", process.stderr)} `, (answer) => {
             rl.close();
-            resolve(answer.trim().toLowerCase() === "y");
+            const trimmed = answer.trim().toLowerCase();
+            resolve(trimmed === "y" || trimmed === "yes" || trimmed === "publish");
         });
     });
 }
@@ -303,13 +359,13 @@ 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 projects. Which one should I audit?\n\n`);
+    process.stderr.write(`\n[temet] I found ${candidates.length} Claude Code projects with session history. Pick one to audit.\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 a project [1-9] or press Enter for the most recent: ", (answer) => {
+        rl.question("[temet] Choose 1-9, or press Enter for the most recent project: ", (answer) => {
             rl.close();
             const trimmed = answer.trim();
             if (!trimmed) {
@@ -372,9 +428,9 @@ export async function runAuditCommand(opts) {
     const commandStartedAt = Date.now();
     let resolvedPath = opts.path;
     if (!opts.quiet) {
-        const resolution = await withSpinner(1, totalSteps, "Discovering sessions", async () => resolveSessionPath(opts.path || undefined, process.env));
+        const resolution = await withSpinner(1, totalSteps, "Finding your sessions", async () => resolveSessionPath(opts.path || undefined, process.env));
         if (!resolution.path) {
-            console.error("[temet] no Claude sessions found. Run this command from a project folder, or use --path <session-dir>.");
+            console.error("[temet] No Claude Code sessions found here. Run this command from a project folder, or use --path <session-dir>.");
             process.exit(1);
         }
         if (!opts.path &&
@@ -414,11 +470,11 @@ export async function runAuditCommand(opts) {
         printBanner();
     }
     if (!opts.quiet) {
-        console.error(`[temet] scanning ${sessionFiles.length} session file(s)...`);
+        console.error(`[temet] reading ${sessionFiles.length} saved session file(s)...`);
     }
     let completedFiles = 0;
     if (!opts.quiet) {
-        writeStepProgress(2, totalSteps, "Scanning sessions", 0, sessionFiles.length);
+        writeStepProgress(2, totalSteps, "Reading your sessions", 0, sessionFiles.length);
     }
     let scanDoneWritten = false;
     const result = await runAudit(sessionFiles, (event) => {
@@ -426,19 +482,19 @@ export async function runAuditCommand(opts) {
             return;
         if (event.phase === "scan") {
             completedFiles += 1;
-            writeStepProgress(2, totalSteps, "Scanning sessions", completedFiles, sessionFiles.length, event.file ? basename(event.file) : undefined);
+            writeStepProgress(2, totalSteps, "Reading your sessions", completedFiles, sessionFiles.length, event.file ? basename(event.file) : undefined);
             return;
         }
         if (!scanDoneWritten) {
             scanDoneWritten = true;
-            writeStepDone(2, totalSteps, "Scanning sessions", `${sessionFiles.length} files`);
+            writeStepDone(2, totalSteps, "Reading your sessions", `${sessionFiles.length} files`);
         }
         if (event.phase === "signals") {
             writeStepDone(3, totalSteps, "Extracting signals", `${formatCount(event.current ?? 0)} signals`, event.elapsedMs);
             return;
         }
         if (event.phase === "patterns") {
-            writeStepDone(4, totalSteps, "Detecting patterns", `${formatCount(event.current ?? 0)} workflows`, event.elapsedMs);
+            writeStepDone(4, totalSteps, "Finding repeated patterns", `${formatCount(event.current ?? 0)} workflows`, event.elapsedMs);
         }
     });
     let { competencies } = result;
@@ -452,7 +508,7 @@ export async function runAuditCommand(opts) {
                 printWarningBox("--narrate requires model access. Set ANTHROPIC_API_KEY or CLAUDE_AUTH_TOKEN.");
             }
             else {
-                const narrated = await withSpinner(5, totalSteps, "Narrating profile", async () => narratorModule.narrateCompetencies(competencies, result.combined, result.workflows, { model: opts.model || undefined }));
+                const narrated = await withSpinner(5, totalSteps, "Writing your profile", async () => narratorModule.narrateCompetencies(competencies, result.combined, result.workflows, { model: opts.model || undefined }));
                 competencies = narrated.competencies;
                 bilan = narrated.bilan || undefined;
             }
@@ -463,13 +519,31 @@ export async function runAuditCommand(opts) {
     }
     if (opts.track) {
         tracking = await trackAuditSnapshot(resolvedPath, result, competencies);
-        // OS notification (only behind --notify, and only if something changed)
-        if (opts.notify && !tracking.skipped && tracking.changes.length > 0) {
-            const { formatNotification, sendNotification } = await import("./lib/notifier.js");
-            const payload = formatNotification(tracking.changes, tracking.current.projectLabel);
-            if (payload) {
-                void sendNotification(payload).catch(() => { });
-            }
+    }
+    const projectLabel = tracking?.current.projectLabel ?? basename(resolvedPath);
+    let reportPath = null;
+    if (opts.openReport && !opts.json) {
+        const reportModule = await import("./lib/report-writer.js");
+        const content = reportModule.buildAuditTextReport(result, competencies, bilan, tracking);
+        reportPath = await reportModule.saveAuditTextReport(projectLabel, content);
+    }
+    const previousMenubarState = await loadMenubarState();
+    const hookInstalled = (await readHookInstalledSafe()) || opts.track;
+    const menubarState = await writeMenubarState({
+        sourcePath: resolvedPath,
+        result,
+        competencies,
+        bilan,
+        tracking,
+        trackingInstalled: hookInstalled,
+        lastReportPath: reportPath ?? (await resolveLastReportPath(projectLabel)),
+        previousState: previousMenubarState,
+    });
+    if (opts.notify && opts.track && tracking && !tracking.skipped) {
+        const { formatProgressNotification, sendNotification } = await import("./lib/notifier.js");
+        const payload = formatProgressNotification(menubarState.progress);
+        if (payload) {
+            void sendNotification(payload).catch(() => { });
         }
     }
     // Publish (runs even in quiet mode — it's a side-effect, not output)
@@ -506,7 +580,7 @@ export async function runAuditCommand(opts) {
             }
         }
     }
-    // Quiet mode: no output
+    // Quiet mode: keep side-effects only
     if (opts.quiet)
         return;
     // Output
@@ -517,13 +591,56 @@ export async function runAuditCommand(opts) {
     else {
         printPretty(result, competencies, bilan, tracking);
     }
-    if (opts.openReport && !opts.json) {
+    if (reportPath && !opts.json) {
         const reportModule = await import("./lib/report-writer.js");
-        const content = reportModule.buildAuditTextReport(result, competencies, bilan, tracking);
-        const projectLabel = tracking?.current.projectLabel ?? basename(resolvedPath);
-        const filePath = await reportModule.saveAuditTextReport(projectLabel, content);
-        await reportModule.openReportFile(filePath);
-        console.error(`${dim(`[temet] opened report: ${filePath}`, process.stderr)}`);
+        await reportModule.openReportFile(reportPath);
+        console.error(`${dim(`[temet] opened report: ${reportPath}`, process.stderr)}`);
+    }
+    // Post-audit onboarding
+    if (!opts.json && !opts.quiet && process.stdin.isTTY) {
+        try {
+            const hookModule = await import("./lib/hook-installer.js");
+            const settingsPath = hookModule.getSettingsPath();
+            const settings = hookModule.readSettings(settingsPath);
+            const hookAlreadyInstalled = hookModule.isHookInstalled(settings);
+            if (!isMacOs()) {
+                if (!opts.track && !hookAlreadyInstalled && !hasDeclinedHook()) {
+                    const answer = await askYesNo("Keep tracking your skills after each Claude Code session?", true);
+                    if (answer) {
+                        const binary = hookModule.resolveTemetBinary();
+                        if (binary) {
+                            const updated = hookModule.installHook(settings, binary);
+                            hookModule.writeSettings(settingsPath, updated);
+                            console.error(`${ok("Tracking enabled", process.stderr)} ${dim("You'll get a notification when your skills meaningfully change.", process.stderr)}`);
+                        }
+                    }
+                    else {
+                        saveHookDeclined();
+                    }
+                }
+            }
+            else {
+                const { isMenubarInstalled, installMenubar } = await import("./lib/menubar-installer.js");
+                if (!isMenubarInstalled()) {
+                    const answer = await askYesNo("Show Temet in your menu bar?", true, hookAlreadyInstalled
+                        ? "Press Enter to install Temet, or type no to skip:"
+                        : "Press Enter to install Temet and turn on automatic tracking, or type no to skip:");
+                    if (answer) {
+                        const result = await installMenubar({
+                            ensureHook: !hookAlreadyInstalled,
+                        });
+                        const suffix = result.hookInstalled
+                            ? "Temet opened and automatic tracking is now enabled."
+                            : "Temet opened.";
+                        console.error(`${ok("Temet installed", process.stderr)} ${dim(suffix, process.stderr)}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`${warn("Temet skipped", process.stderr)} ${dim(message, process.stderr)}`);
+        }
     }
     if (!opts.json) {
         console.error(`${ok("done", process.stderr)} ${dim(`in ${formatMs(Date.now() - commandStartedAt)}`, process.stderr)}`);

package/dist/index.js

@@ -15,8 +15,12 @@ const HELP = `Temet CLI — discover the skills you already demonstrate in AI wo
 
 Commands:
 \ttemet audit [--path <session-dir>]        Analyze local sessions, surface skills and workflows
+\ttemet traces [--path <session-dir>]       Show the evidence behind the strongest signals
+\ttemet plan [--path <session-dir>]         Turn the current audit into an operating plan
 \ttemet install-hook                        Auto-audit after every Claude Code session
 \ttemet uninstall-hook                      Remove the SessionEnd hook
+\ttemet install-menubar                     Install Temet in the macOS menu bar
+\ttemet uninstall-menubar                   Remove Temet from the macOS menu bar
 \ttemet connect --address <hex> --token <t> Connect your MCP client to your Temet card
 \ttemet install-handler                     Register temet:// protocol handler
 
@@ -32,16 +36,20 @@ Audit options:
 
 Advanced:
 \t--narrate        Enrich results with an LLM (requires model access: ANTHROPIC_API_KEY or CLAUDE_AUTH_TOKEN)
+\t--no-narrate     Disable automatic narration even if model access is available
 \t--model <id>     Model to use for narration (default: claude-haiku-4-5-20251001)
 
 Examples:
 \ttemet audit                                            Auto-detect sessions from cwd
 \ttemet audit                                            Open the text report by default
+\ttemet traces                                           Inspect the proof behind the current reading
+\ttemet plan                                             Get the current operating plan
 \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
+\ttemet install-menubar                                  Install and open Temet on macOS
 `;
 function printHelp(exitCode = 0) {
     console.log(HELP);
@@ -151,6 +159,12 @@ function parseArgs(argv) {
             options: buildAuditCliOptions(flags, process.env),
         };
     }
+    if (command === "traces" || command === "plan") {
+        return {
+            command,
+            options: buildAuditCliOptions(flags, process.env),
+        };
+    }
     if (command === "connect") {
         return {
             command,
@@ -169,6 +183,9 @@ function parseArgs(argv) {
     if (command === "install-hook" || command === "uninstall-hook") {
         return { command, dryRun };
     }
+    if (command === "install-menubar" || command === "uninstall-menubar") {
+        return { command, dryRun };
+    }
     console.error(`Unknown command: ${command}`);
     printHelp(1);
 }
@@ -494,6 +511,16 @@ async function run() {
         await runAuditCommand(parsed.options);
         return;
     }
+    if (parsed.command === "traces") {
+        const { runTracesCommand } = await import("./traces.js");
+        await runTracesCommand(parsed.options);
+        return;
+    }
+    if (parsed.command === "plan") {
+        const { runPlanCommand } = await import("./plan.js");
+        await runPlanCommand(parsed.options);
+        return;
+    }
     if (parsed.command === "connect" || parsed.command === "connect-url") {
         await runWriteFlow(parsed.command, parsed.options);
         return;
@@ -540,6 +567,35 @@ async function run() {
         console.log("[temet] SessionEnd hook removed.");
         return;
     }
+    if (parsed.command === "install-menubar") {
+        const { installMenubar } = await import("./lib/menubar-installer.js");
+        const result = await installMenubar({
+            dryRun: parsed.dryRun,
+            ensureHook: true,
+        });
+        if (parsed.dryRun) {
+            console.log(`[temet] dry-run menubar install path: ${result.appPath}`);
+            console.log(`[temet] dry-run menubar config path: ${result.configPath}`);
+            return;
+        }
+        console.log(`[temet] Temet installed: ${result.appPath}`);
+        if (result.hookInstalled) {
+            console.log("[temet] Tracking enabled via SessionEnd hook.");
+        }
+        console.log("[temet] Temet opened.");
+        return;
+    }
+    if (parsed.command === "uninstall-menubar") {
+        const { uninstallMenubar } = await import("./lib/menubar-installer.js");
+        const result = await uninstallMenubar({ dryRun: parsed.dryRun });
+        if (parsed.dryRun) {
+            console.log(`[temet] dry-run menubar uninstall path: ${result.appPath}`);
+            return;
+        }
+        console.log("[temet] Temet removed.");
+        console.log("[temet] Tracking remains active — run temet uninstall-hook to disable it.");
+        return;
+    }
     if (parsed.command === "install-handler") {
         await installProtocolHandler(parsed.dryRun);
         console.log("[temet] next: click a Quick connect button in Temet.");

package/dist/lib/audit-tracking.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
+import { humanizeSessionDir } from "./path-resolver.js";
 const PROFICIENCY_ORDER = {
     novice: 0,
     advanced_beginner: 1,
@@ -26,8 +27,18 @@ export function buildProjectKey(sourcePath) {
 }
 function buildProjectLabel(sourcePath) {
     const resolved = path.resolve(sourcePath);
-    const base = path.basename(resolved);
-    return base || resolved;
+    const slug = path.basename(resolved);
+    if (slug.startsWith("-")) {
+        const segments = slug.slice(1).split("-").filter(Boolean);
+        if (segments.length >= 2) {
+            return `${segments[segments.length - 2]}-${segments[segments.length - 1]}`;
+        }
+        if (segments.length === 1) {
+            return segments[0];
+        }
+    }
+    const humanized = humanizeSessionDir(resolved);
+    return path.basename(humanized) || path.basename(resolved) || resolved;
 }
 export function buildAuditSnapshot(sourcePath, result, competencies) {
     return {

package/dist/lib/cli-args.js

@@ -14,6 +14,7 @@ export function parseFlagBag(args) {
         if (arg === "--dry-run" ||
             arg === "--track" ||
             arg === "--narrate" ||
+            arg === "--no-narrate" ||
             arg === "--open-report" ||
             arg === "--json" ||
             arg === "--quiet" ||
@@ -48,7 +49,11 @@ export function buildAuditCliOptions(flags, env) {
     return {
         path: pathVal,
         track: Boolean(flags.get("track")),
-        narrate: Boolean(flags.get("narrate")),
+        narrate: !Boolean(flags.get("no-narrate")) &&
+            (Boolean(flags.get("narrate")) ||
+                (!json &&
+                    !quiet &&
+                    Boolean(env.CLAUDE_AUTH_TOKEN || env.ANTHROPIC_API_KEY))),
         openReport: explicitOpenReport || (!json && !quiet),
         json,
         quiet,

package/dist/lib/diagnostic-runner.d.ts

@@ -0,0 +1,13 @@
+import type { AuditCliOptions } from "./cli-args.js";
+import { type TrackingResult } from "./audit-tracking.js";
+import { type AuditResult } from "./session-audit.js";
+import type { CompetencyEntry } from "./types.js";
+export type ResolvedDiagnostics = {
+    resolvedPath: string;
+    result: AuditResult;
+    competencies: CompetencyEntry[];
+    bilan?: string;
+    tracking?: TrackingResult;
+};
+export declare function resolveDiagnostics(opts: AuditCliOptions): Promise<ResolvedDiagnostics>;
+export declare function defaultProjectLabel(resolvedPath: string): string;

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/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;
+}>;