@temet/cli 0.3.0 → 0.3.1

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

@@ -4,11 +4,13 @@
 import { basename } 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";
 export function buildAuditJsonOutput(result, competencies, bilan, tracking) {
     return {
         sessions: result.sessionCount,
         messages: result.messageCount,
+        prompts: result.promptCount,
         toolCalls: result.toolCallCount,
         competencies,
         workflows: result.workflows,
@@ -297,6 +299,34 @@ async function confirmPublish(competencyCount, address) {
         });
     });
 }
+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`);
+    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.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 function resolvePublishMode(yes, isTTY) {
     if (yes)
         return "skip";
@@ -338,10 +368,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, "Discovering 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>.");
+            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);
     }
@@ -351,11 +416,9 @@ export async function runAuditCommand(opts) {
     if (!opts.quiet) {
         console.error(`[temet] scanning ${sessionFiles.length} 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, "Scanning sessions", 0, sessionFiles.length);
     }
     let scanDoneWritten = false;
     const result = await runAudit(sessionFiles, (event) => {
@@ -363,19 +426,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, "Scanning 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, "Scanning 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, "Detecting patterns", `${formatCount(event.current ?? 0)} workflows`, event.elapsedMs);
         }
     });
     let { competencies } = result;
@@ -389,7 +452,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, "Narrating profile", async () => narratorModule.narrateCompetencies(competencies, result.combined, result.workflows, { model: opts.model || undefined }));
                 competencies = narrated.competencies;
                 bilan = narrated.bilan || undefined;
             }
@@ -399,7 +462,7 @@ export async function runAuditCommand(opts) {
         }
     }
     if (opts.track) {
-        tracking = await trackAuditSnapshot(opts.path, result, competencies);
+        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");
@@ -454,6 +517,14 @@ export async function runAuditCommand(opts) {
     else {
         printPretty(result, competencies, bilan, tracking);
     }
+    if (opts.openReport && !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)}`);
+    }
     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";
@@ -24,6 +23,7 @@ Commands:
 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)
@@ -36,8 +36,10 @@ Advanced:
 
 Examples:
 \ttemet audit                                            Auto-detect sessions from cwd
+\ttemet audit                                            Open the text report by default
 \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
 `;
@@ -144,19 +146,9 @@ 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 === "connect") {

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,7 @@ export function parseFlagBag(args) {
         if (arg === "--dry-run" ||
             arg === "--track" ||
             arg === "--narrate" ||
+            arg === "--open-report" ||
             arg === "--json" ||
             arg === "--quiet" ||
             arg === "--notify" ||
@@ -41,12 +42,16 @@ 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")),
+        openReport: explicitOpenReport || (!json && !quiet),
+        json,
+        quiet,
         notify: Boolean(flags.get("notify")),
         publish: Boolean(flags.get("publish")),
         yes: Boolean(flags.get("yes")),

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/path-resolver.d.ts

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

package/dist/lib/path-resolver.js

@@ -1,10 +1,75 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
+const DEFAULT_CLAUDE_ROOT = path.join(homedir(), ".claude", "projects");
 /** Convert an absolute project directory to the Claude Code session directory slug. */
 export function cwdToSessionDir(cwd) {
     const slug = path.resolve(cwd).replace(/\//g, "-");
-    return path.join(homedir(), ".claude", "projects", slug);
+    return path.join(DEFAULT_CLAUDE_ROOT, slug);
+}
+export function humanizeSessionDir(sessionDir) {
+    const slug = path.basename(sessionDir);
+    if (!slug)
+        return sessionDir;
+    if (slug.startsWith("-")) {
+        return slug.replace(/-/g, "/");
+    }
+    return slug;
+}
+function hasJsonlSessions(dir) {
+    try {
+        for (const entry of readdirSync(dir)) {
+            const full = path.join(dir, entry);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                if (hasJsonlSessions(full))
+                    return true;
+                continue;
+            }
+            if (stat.isFile() && entry.endsWith(".jsonl"))
+                return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+function candidateFromSessionDir(sessionDir) {
+    if (!existsSync(sessionDir) || !hasJsonlSessions(sessionDir))
+        return null;
+    let updatedAtMs = 0;
+    try {
+        updatedAtMs = statSync(sessionDir).mtimeMs;
+    }
+    catch {
+        updatedAtMs = 0;
+    }
+    return {
+        sessionDir,
+        label: humanizeSessionDir(sessionDir),
+        updatedAtMs,
+    };
+}
+export function findClaudeProjectCandidates(claudeRoot = DEFAULT_CLAUDE_ROOT) {
+    try {
+        return readdirSync(claudeRoot)
+            .map((entry) => path.join(claudeRoot, entry))
+            .filter((full) => {
+            try {
+                return statSync(full).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })
+            .map(candidateFromSessionDir)
+            .filter((candidate) => candidate !== null)
+            .sort((a, b) => b.updatedAtMs - a.updatedAtMs);
+    }
+    catch {
+        return [];
+    }
 }
 /**
  * Try to read the JSON stdin from a Claude Code hook (non-blocking).
@@ -13,8 +78,6 @@ export function cwdToSessionDir(cwd) {
  */
 export function readHookStdin() {
     try {
-        // Only attempt if stdin is piped (non-TTY) AND we're in a hook context.
-        // CLAUDECODE env var is set when running inside Claude Code.
         if (process.stdin.isTTY)
             return null;
         if (!process.env.CLAUDECODE)
@@ -32,25 +95,58 @@ export function readHookStdin() {
  * 2. $CLAUDE_PROJECT_DIR env var
  * 3. stdin JSON cwd (hook context)
  * 4. process.cwd()
+ * 5. most recent valid Claude project
  */
-export function resolveSessionPath(explicit, env) {
-    if (explicit)
-        return explicit;
-    // Priority 2: CLAUDE_PROJECT_DIR env var (guaranteed in Claude Code hooks)
-    const projectDir = env.CLAUDE_PROJECT_DIR;
-    if (projectDir) {
-        const d = cwdToSessionDir(projectDir);
-        if (existsSync(d))
-            return d;
-    }
-    // Priority 3: stdin JSON cwd (hook context)
-    const hookInput = readHookStdin();
-    if (hookInput?.cwd) {
-        const d = cwdToSessionDir(hookInput.cwd);
-        if (existsSync(d))
-            return d;
-    }
-    // Priority 4: process.cwd()
-    const d = cwdToSessionDir(process.cwd());
-    return existsSync(d) ? d : null;
+export function resolveSessionPath(explicit, env, options = {}) {
+    if (explicit) {
+        return {
+            path: explicit,
+            source: "explicit",
+            candidates: [],
+        };
+    }
+    const cwd = options.cwd ?? process.cwd();
+    const claudeRoot = options.claudeRoot ?? DEFAULT_CLAUDE_ROOT;
+    const fromEnv = env.CLAUDE_PROJECT_DIR
+        ? candidateFromSessionDir(path.join(claudeRoot, path.resolve(env.CLAUDE_PROJECT_DIR).replace(/\//g, "-")))
+        : null;
+    if (fromEnv) {
+        return {
+            path: fromEnv.sessionDir,
+            source: "env",
+            candidates: [fromEnv],
+        };
+    }
+    const hookInput = options.hookInput ?? readHookStdin();
+    const fromStdin = hookInput?.cwd
+        ? candidateFromSessionDir(path.join(claudeRoot, path.resolve(hookInput.cwd).replace(/\//g, "-")))
+        : null;
+    if (fromStdin) {
+        return {
+            path: fromStdin.sessionDir,
+            source: "stdin",
+            candidates: [fromStdin],
+        };
+    }
+    const fromCwd = candidateFromSessionDir(path.join(claudeRoot, path.resolve(cwd).replace(/\//g, "-")));
+    if (fromCwd) {
+        return {
+            path: fromCwd.sessionDir,
+            source: "cwd",
+            candidates: [fromCwd],
+        };
+    }
+    const candidates = findClaudeProjectCandidates(claudeRoot);
+    if (candidates.length > 0) {
+        return {
+            path: candidates[0].sessionDir,
+            source: "recent",
+            candidates,
+        };
+    }
+    return {
+        path: null,
+        source: "none",
+        candidates: [],
+    };
 }

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

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

package/dist/lib/profile-report.js

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

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

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

package/dist/lib/report-writer.js

@@ -0,0 +1,73 @@
+import { execFile } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { buildSkillAuditReport } from "./profile-report.js";
+const execFileAsync = promisify(execFile);
+const TEMET_WORDMARK = [
+    "████████╗███████╗███╗   ███╗███████╗████████╗",
+    "╚══██╔══╝██╔════╝████╗ ████║██╔════╝╚══██╔══╝",
+    "   ██║   █████╗  ██╔████╔██║█████╗     ██║   ",
+    "   ██║   ██╔══╝  ██║╚██╔╝██║██╔══╝     ██║   ",
+    "   ██║   ███████╗██║ ╚═╝ ██║███████╗   ██║   ",
+    "   ╚═╝   ╚══════╝╚═╝     ╚═╝╚══════╝   ╚═╝   ",
+];
+function divider(char = "─", width = 66) {
+    return char.repeat(width);
+}
+function section(title, body) {
+    return [title, divider(), "", ...body, ""];
+}
+export function buildAuditTextReport(result, competencies, bilan, tracking) {
+    const lines = [];
+    const profile = buildSkillAuditReport(result, competencies, tracking);
+    lines.push(...TEMET_WORDMARK, "", "By Temet · Encode human intelligence", "temet-skills-audit", "", profile.title, "", profile.subtitle, "");
+    lines.push(...section(`YOUR ${profile.tacitSkills.length} TACIT SKILLS`, profile.tacitSkills.flatMap((entry, index) => {
+        const header = entry.tagline
+            ? `${index + 1}. ${entry.title} — ${entry.tagline}`
+            : `${index + 1}. ${entry.title}`;
+        return [header, "", entry.body, ""];
+    })));
+    if (profile.meaningfulChanges.length > 0) {
+        lines.push(...section("WHAT CHANGED SINCE THE LAST AUDIT", profile.meaningfulChanges));
+    }
+    lines.push(...section("YOUR 3 BLIND SPOTS", profile.blindSpots.flatMap((entry, index) => [
+        `${index + 1}. ${entry.title}`,
+        "",
+        entry.body,
+        "",
+    ])));
+    lines.push(...section("YOUR PROFESSIONAL DNA", [
+        bilan?.trim() || profile.professionalDna,
+    ]));
+    lines.push(...section("THE META-SKILL THAT TIES IT ALL TOGETHER", [
+        profile.metaSkill.title,
+        "",
+        profile.metaSkill.body,
+    ]));
+    lines.push(divider(), "", "Thanks for reading.", "Arnaud");
+    return `${lines.join("\n").trim()}\n`;
+}
+export function buildReportPath(projectLabel, now = new Date()) {
+    const date = now.toISOString().replace(/:/g, "-");
+    const safeLabel = projectLabel.replace(/[^a-zA-Z0-9._-]+/g, "-");
+    return path.join(homedir(), ".temet", "reports", safeLabel, `temet-skills-audit-${date}.txt`);
+}
+export async function saveAuditTextReport(projectLabel, content, now = new Date()) {
+    const filePath = buildReportPath(projectLabel, now);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf8");
+    return filePath;
+}
+export async function openReportFile(filePath, platform = process.platform) {
+    if (platform === "darwin") {
+        await execFileAsync("open", ["-a", "TextEdit", filePath]);
+        return;
+    }
+    if (platform === "win32") {
+        await execFileAsync("notepad", [filePath]);
+        return;
+    }
+    await execFileAsync("xdg-open", [filePath]);
+}

package/dist/lib/session-audit.d.ts

@@ -5,6 +5,7 @@ import type { CompetencyEntry } from "./types.js";
 export type AuditResult = {
     sessionCount: number;
     messageCount: number;
+    promptCount: number;
     toolCallCount: number;
     signalCount: number;
     workflowCount: number;

package/dist/lib/session-audit.js

@@ -78,9 +78,11 @@ export async function runAudit(sessionFiles, onProgress) {
         elapsedMs: Date.now() - workflowStartedAt,
     });
     const competencies = mapSignalsToCompetencies(allSignals);
+    const promptCount = combined.messages.filter((message) => message.role === "user").length;
     return {
         sessionCount: sessionFiles.length,
         messageCount: combined.messages.length,
+        promptCount,
         toolCallCount: combined.toolCalls.length,
         signalCount: allSignals.length,
         workflowCount: workflows.length,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@temet/cli",
-	"version": "0.3.0",
+	"version": "0.3.1",
 	"description": "Temet CLI — discover the skills you already demonstrate in AI work",
 	"keywords": [
 		"temet",