@temet/cli 0.3.0 → 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.d.ts

@@ -5,6 +5,7 @@ export type AuditOptions = {
     path: string;
     track: boolean;
     narrate: boolean;
+    openReport: boolean;
     json: boolean;
     quiet: boolean;
     notify: boolean;
@@ -15,7 +16,7 @@ export type AuditOptions = {
     token: string;
     relayUrl: string;
 };
-export declare function buildAuditJsonOutput(result: Pick<AuditResult, "sessionCount" | "messageCount" | "toolCallCount" | "workflows">, competencies: CompetencyEntry[], bilan?: string, tracking?: Pick<TrackingResult, "changes" | "latestPath">): {
+export declare function buildAuditJsonOutput(result: Pick<AuditResult, "sessionCount" | "messageCount" | "promptCount" | "toolCallCount" | "workflows">, competencies: CompetencyEntry[], bilan?: string, tracking?: Pick<TrackingResult, "changes" | "latestPath">): {
     tracking?: {
         latestPath: string;
         changes: AuditChange[];
@@ -23,6 +24,7 @@ export declare function buildAuditJsonOutput(result: Pick<AuditResult, "sessionC
     bilan?: string | undefined;
     sessions: number;
     messages: number;
+    prompts: number;
     toolCalls: number;
     competencies: CompetencyEntry[];
     workflows: import("./lib/workflow-detector.js").DetectedWorkflow[];

package/dist/audit.js

@@ -1,14 +1,19 @@
 /**
  * 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,
         messages: result.messageCount,
+        prompts: result.promptCount,
         toolCalls: result.toolCallCount,
         competencies,
         workflows: result.workflows,
@@ -271,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) {
@@ -282,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) {
@@ -291,9 +348,38 @@ 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");
+        });
+    });
+}
+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 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 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);
         });
     });
 }
@@ -338,10 +424,45 @@ async function publishCompetencies(competencies, opts) {
 }
 // ---------- Main ----------
 export async function runAuditCommand(opts) {
-    const sessionFiles = findSessionFiles(opts.path);
+    const totalSteps = 4 + (opts.narrate ? 1 : 0) + (opts.publish ? 1 : 0);
+    const commandStartedAt = Date.now();
+    let resolvedPath = opts.path;
+    if (!opts.quiet) {
+        const resolution = await withSpinner(1, totalSteps, "Finding your sessions", async () => resolveSessionPath(opts.path || undefined, process.env));
+        if (!resolution.path) {
+            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 &&
+            !opts.json &&
+            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(`${dim(`[temet] using ${label}`, process.stderr)}\n`);
+            }
+        }
+        else {
+            resolvedPath = resolution.path;
+            const label = resolution.candidates[0]?.label;
+            if (label && resolution.source !== "explicit") {
+                process.stderr.write(`${dim(`[temet] using ${label}`, process.stderr)}\n`);
+            }
+        }
+    }
+    else {
+        const resolution = resolveSessionPath(opts.path || undefined, process.env);
+        if (!resolution.path) {
+            process.exit(1);
+        }
+        resolvedPath = resolution.path;
+    }
+    const sessionFiles = findSessionFiles(resolvedPath);
     if (sessionFiles.length === 0) {
         if (!opts.quiet) {
-            console.error(`[temet] no .jsonl session files found in ${opts.path}`);
+            console.error(`[temet] no .jsonl session files found in ${resolvedPath}`);
         }
         process.exit(1);
     }
@@ -349,13 +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)...`);
     }
-    const totalSteps = 3 + (opts.narrate ? 1 : 0) + (opts.publish ? 1 : 0);
     let completedFiles = 0;
-    const commandStartedAt = Date.now();
     if (!opts.quiet) {
-        writeStepProgress(1, totalSteps, "Scanning sessions", 0, sessionFiles.length);
+        writeStepProgress(2, totalSteps, "Reading your sessions", 0, sessionFiles.length);
     }
     let scanDoneWritten = false;
     const result = await runAudit(sessionFiles, (event) => {
@@ -363,19 +482,19 @@ export async function runAuditCommand(opts) {
             return;
         if (event.phase === "scan") {
             completedFiles += 1;
-            writeStepProgress(1, 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(1, totalSteps, "Scanning sessions", `${sessionFiles.length} files`);
+            writeStepDone(2, totalSteps, "Reading your sessions", `${sessionFiles.length} files`);
         }
         if (event.phase === "signals") {
-            writeStepDone(2, totalSteps, "Extracting signals", `${formatCount(event.current ?? 0)} signals`, event.elapsedMs);
+            writeStepDone(3, totalSteps, "Extracting signals", `${formatCount(event.current ?? 0)} signals`, event.elapsedMs);
             return;
         }
         if (event.phase === "patterns") {
-            writeStepDone(3, 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;
@@ -389,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(4, 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;
             }
@@ -399,14 +518,32 @@ export async function runAuditCommand(opts) {
         }
     }
     if (opts.track) {
-        tracking = await trackAuditSnapshot(opts.path, 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(() => { });
-            }
+        tracking = await trackAuditSnapshot(resolvedPath, result, competencies);
+    }
+    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)
@@ -443,7 +580,7 @@ export async function runAuditCommand(opts) {
             }
         }
     }
-    // Quiet mode: no output
+    // Quiet mode: keep side-effects only
     if (opts.quiet)
         return;
     // Output
@@ -454,6 +591,57 @@ export async function runAuditCommand(opts) {
     else {
         printPretty(result, competencies, bilan, tracking);
     }
+    if (reportPath && !opts.json) {
+        const reportModule = await import("./lib/report-writer.js");
+        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

@@ -5,7 +5,6 @@ import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 import { promisify } from "node:util";
 import { buildAuditCliOptions, parseFlagBag, readOptionalString, } from "./lib/cli-args.js";
-import { resolveSessionPath } from "./lib/path-resolver.js";
 const execFileAsync = promisify(execFile);
 const DEFAULT_RELAY_URL = "https://temet-relay.ramponneau.workers.dev/mcp";
 const DEFAULT_SERVER_NAME = "temet";
@@ -16,14 +15,19 @@ 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
 
 Audit options:
 \t--path <dir>     Directory containing .jsonl session files (auto-detected if omitted)
 \t--track          Save a local snapshot and compare against the previous audit
+\t--open-report    Explicitly save and open the text report (opened by default unless --json or --quiet)
 \t--json           Output structured JSON instead of terminal display
 \t--quiet          Suppress all output (for background hooks)
 \t--notify         Send an OS notification on skill changes (used with --track)
@@ -32,14 +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);
@@ -144,19 +154,15 @@ function parseArgs(argv) {
     const { flags, positionals } = parseFlagBag(rest);
     const dryRun = Boolean(flags.get("dry-run"));
     if (command === "audit") {
-        const options = buildAuditCliOptions(flags, process.env);
-        if (!options.path) {
-            // Auto-detect session path
-            const detected = resolveSessionPath(undefined, process.env);
-            if (!detected) {
-                console.error("[temet] could not auto-detect session directory. Use --path <session-dir>");
-                process.exit(1);
-            }
-            options.path = detected;
-        }
         return {
             command,
-            options,
+            options: buildAuditCliOptions(flags, process.env),
+        };
+    }
+    if (command === "traces" || command === "plan") {
+        return {
+            command,
+            options: buildAuditCliOptions(flags, process.env),
         };
     }
     if (command === "connect") {
@@ -177,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);
 }
@@ -502,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;
@@ -548,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.d.ts

@@ -3,6 +3,7 @@ export type AuditCliOptions = {
     path: string;
     track: boolean;
     narrate: boolean;
+    openReport: boolean;
     json: boolean;
     quiet: boolean;
     notify: boolean;

package/dist/lib/cli-args.js

@@ -14,6 +14,8 @@ export function parseFlagBag(args) {
         if (arg === "--dry-run" ||
             arg === "--track" ||
             arg === "--narrate" ||
+            arg === "--no-narrate" ||
+            arg === "--open-report" ||
             arg === "--json" ||
             arg === "--quiet" ||
             arg === "--notify" ||
@@ -41,12 +43,20 @@ export function readOptionalString(flags, key) {
 }
 export function buildAuditCliOptions(flags, env) {
     const pathVal = readOptionalString(flags, "path") ?? "";
+    const json = Boolean(flags.get("json"));
+    const quiet = Boolean(flags.get("quiet"));
+    const explicitOpenReport = Boolean(flags.get("open-report"));
     return {
         path: pathVal,
         track: Boolean(flags.get("track")),
-        narrate: Boolean(flags.get("narrate")),
-        json: Boolean(flags.get("json")),
-        quiet: Boolean(flags.get("quiet")),
+        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,
         notify: Boolean(flags.get("notify")),
         publish: Boolean(flags.get("publish")),
         yes: Boolean(flags.get("yes")),

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;