@temet/cli 0.3.1 → 0.3.3

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 &&
@@ -403,7 +459,19 @@ export async function runAuditCommand(opts) {
         }
         resolvedPath = resolution.path;
     }
-    const sessionFiles = findSessionFiles(resolvedPath);
+    let sessionFiles = findSessionFiles(resolvedPath);
+    if (sessionFiles.length === 0 && !opts.path && !opts.quiet && !opts.json) {
+        const { findClaudeProjectCandidates } = await import("./lib/path-resolver.js");
+        const candidates = findClaudeProjectCandidates();
+        if (candidates.length > 0) {
+            const selected = await chooseSessionCandidate(candidates);
+            if (selected) {
+                resolvedPath = selected.sessionDir;
+                sessionFiles = findSessionFiles(resolvedPath);
+                process.stderr.write(`${dim(`[temet] using ${selected.label}`, process.stderr)}\n`);
+            }
+        }
+    }
     if (sessionFiles.length === 0) {
         if (!opts.quiet) {
             console.error(`[temet] no .jsonl session files found in ${resolvedPath}`);
@@ -414,11 +482,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 +494,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 +520,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 +531,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 +592,7 @@ export async function runAuditCommand(opts) {
             }
         }
     }
-    // Quiet mode: no output
+    // Quiet mode: keep side-effects only
     if (opts.quiet)
         return;
     // Output
@@ -517,13 +603,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/doctor.d.ts

@@ -0,0 +1,5 @@
+export type DoctorCliOptions = {
+    path?: string;
+    json: boolean;
+};
+export declare function runDoctorCommand(opts: DoctorCliOptions): Promise<void>;

package/dist/doctor.js

@@ -0,0 +1,79 @@
+import { existsSync } from "node:fs";
+import { basename } from "node:path";
+import { findClaudeProjectCandidates, resolveSessionPath, } from "./lib/path-resolver.js";
+import { getSettingsPath, isHookInstalled, readSettings } from "./lib/hook-installer.js";
+import { getMenubarAppPath, isMenubarInstalled } from "./lib/menubar-installer.js";
+import { getMenubarConfigPath, getMenubarStatePath, } from "./lib/menubar-state.js";
+import { resolveAuth } from "./lib/narrator-lite.js";
+import { findSessionFiles } from "./lib/session-audit.js";
+function buildCheck(id, label, status, detail) {
+    return { id, label, status, detail };
+}
+function iconFor(status) {
+    return status === "ok" ? "OK" : "WARN";
+}
+export async function runDoctorCommand(opts) {
+    const resolution = resolveSessionPath(opts.path || undefined, process.env);
+    const resolvedPath = resolution.path;
+    const sessionFiles = resolvedPath ? findSessionFiles(resolvedPath) : [];
+    const hookInstalled = isHookInstalled(readSettings(getSettingsPath()));
+    const narrationAvailable = resolveAuth() !== null;
+    const menubarInstalled = process.platform === "darwin" && isMenubarInstalled();
+    const menubarConfigExists = existsSync(getMenubarConfigPath());
+    const menubarStateExists = existsSync(getMenubarStatePath());
+    const candidates = findClaudeProjectCandidates();
+    const checks = [
+        buildCheck("sessions-root", "Claude Code projects", candidates.length > 0 ? "ok" : "warn", candidates.length > 0
+            ? `${candidates.length} project(s) with session history found`
+            : "No Claude Code project with session history was found"),
+        buildCheck("resolved-path", "Resolved session source", resolvedPath ? "ok" : "warn", resolvedPath
+            ? `${resolution.source}: ${basename(resolvedPath)}`
+            : "No session path could be resolved automatically"),
+        buildCheck("session-files", "Session files", sessionFiles.length > 0 ? "ok" : "warn", resolvedPath
+            ? `${sessionFiles.length} .jsonl file(s) in ${resolvedPath}`
+            : "No resolved project to scan"),
+        buildCheck("hook", "SessionEnd hook", hookInstalled ? "ok" : "warn", hookInstalled
+            ? `Installed in ${getSettingsPath()}`
+            : "Not installed. Run temet install-hook"),
+        buildCheck("narration", "Narration access", narrationAvailable ? "ok" : "warn", narrationAvailable
+            ? "Token detected for LLM narration"
+            : "No ANTHROPIC_API_KEY or CLAUDE_AUTH_TOKEN detected"),
+        buildCheck("menubar-app", "Temet app", process.platform !== "darwin" ? "warn" : menubarInstalled ? "ok" : "warn", process.platform !== "darwin"
+            ? "Temet app is only available on macOS"
+            : menubarInstalled
+                ? `Installed at ${getMenubarAppPath()}`
+                : "Not installed. Run temet install-menubar"),
+        buildCheck("menubar-config", "Temet app config", process.platform !== "darwin"
+            ? "warn"
+            : menubarConfigExists
+                ? "ok"
+                : "warn", process.platform !== "darwin"
+            ? "Not applicable on this platform"
+            : menubarConfigExists
+                ? `Config present at ${getMenubarConfigPath()}`
+                : "No menubar config found yet"),
+        buildCheck("menubar-state", "Temet app state", menubarStateExists ? "ok" : "warn", menubarStateExists
+            ? `Sidecar present at ${getMenubarStatePath()}`
+            : "No menubar state written yet. Run temet audit --track"),
+    ];
+    const report = {
+        version: 1,
+        checks,
+        summary: {
+            ok: checks.filter((check) => check.status === "ok").length,
+            warn: checks.filter((check) => check.status === "warn").length,
+        },
+    };
+    if (opts.json) {
+        console.log(JSON.stringify(report, null, "\t"));
+        return;
+    }
+    console.log("Temet doctor");
+    console.log("");
+    for (const check of checks) {
+        console.log(`${iconFor(check.status)}  ${check.label}`);
+        console.log(`    ${check.detail}`);
+    }
+    console.log("");
+    console.log(`Summary: ${report.summary.ok} OK, ${report.summary.warn} warning${report.summary.warn === 1 ? "" : "s"}`);
+}

package/dist/index.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import { execFile } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { buildAuditCliOptions, parseFlagBag, readOptionalString, } from "./lib/cli-args.js";
 const execFileAsync = promisify(execFile);
@@ -11,12 +13,28 @@ 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 — discover the skills you already demonstrate in AI work
+const PACKAGE_JSON_PATH = fileURLToPath(new URL("../package.json", import.meta.url));
+function readCliVersion() {
+    try {
+        const packageJson = JSON.parse(readFileSync(PACKAGE_JSON_PATH, "utf8"));
+        return packageJson.version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+const CLI_VERSION = readCliVersion();
+const HELP = `Temet CLI ${CLI_VERSION} — discover the skills you already demonstrate in AI work
 
 Commands:
 \ttemet audit [--path <session-dir>]        Analyze local sessions, surface skills and workflows
+\ttemet doctor [--path <session-dir>]       Check local Temet setup, sessions, hook, and app state
+\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,21 +50,30 @@ 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 doctor                                           Check whether Temet is fully wired on this machine
 \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);
     process.exit(exitCode);
 }
+function printVersion() {
+    console.log(CLI_VERSION);
+    process.exit(0);
+}
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -139,6 +166,9 @@ function parseConnectUrlOptions(flags, positionals) {
     };
 }
 function parseArgs(argv) {
+    if (argv.includes("-v") || argv.includes("--version")) {
+        printVersion();
+    }
     if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) {
         printHelp(0);
     }
@@ -151,6 +181,21 @@ function parseArgs(argv) {
             options: buildAuditCliOptions(flags, process.env),
         };
     }
+    if (command === "doctor") {
+        return {
+            command,
+            options: {
+                path: readOptionalString(flags, "path") ?? undefined,
+                json: Boolean(flags.get("json")),
+            },
+        };
+    }
+    if (command === "traces" || command === "plan") {
+        return {
+            command,
+            options: buildAuditCliOptions(flags, process.env),
+        };
+    }
     if (command === "connect") {
         return {
             command,
@@ -169,6 +214,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 +542,21 @@ async function run() {
         await runAuditCommand(parsed.options);
         return;
     }
+    if (parsed.command === "doctor") {
+        const { runDoctorCommand } = await import("./doctor.js");
+        await runDoctorCommand(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 +603,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;