@temet/cli 0.3.2 → 0.3.4

package/dist/audit.js

@@ -6,7 +6,7 @@ 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 { findCodexSessionFiles, 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) {
@@ -276,11 +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 over time`);
+        console.log(`  ${DIM}temet audit --track${RESET}              Keep learning from every Claude Code session`);
     }
-    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(`  ${DIM}temet traces${RESET}                    See why Temet says this about you`);
+    console.log(`  ${DIM}temet plan${RESET}                      Get one focused next step to improve with AI`);
+    console.log(`  ${DIM}temet audit --publish${RESET}            Share this profile on your Temet card`);
     console.log("");
     console.log(`${ok("Audit complete:", process.stdout)} ${formatCount(competencies.length)} skills surfaced from ${formatCount(result.sessionCount)} sessions`);
     if (tracking) {
@@ -308,6 +308,13 @@ function hasDeclinedHook() {
 function saveHookDeclined() {
     writePrefs({ ...readPrefs(), hookDeclined: true });
 }
+function clearHookDeclined() {
+    const prefs = readPrefs();
+    if (!("hookDeclined" in prefs))
+        return;
+    delete prefs.hookDeclined;
+    writePrefs(prefs);
+}
 function isMacOs() {
     return process.platform === "darwin";
 }
@@ -321,7 +328,7 @@ async function readHookInstalledSafe() {
     }
 }
 // ---------- Confirmation ----------
-async function askYesNo(question, defaultYes, hintOverride) {
+async function askYesNo(question, defaultYes, hintOverride, options) {
     if (!process.stdin.isTTY)
         return false;
     const rl = createInterface({ input: process.stdin, output: process.stderr });
@@ -330,7 +337,13 @@ async function askYesNo(question, defaultYes, hintOverride) {
             ? "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) => {
+        const labelLine = options?.label
+            ? `${colorize("●", CYAN, process.stderr)} ${BOLD}${options.label}${RESET}\n`
+            : "";
+        const descriptionLine = options?.description
+            ? `${dim(options.description, process.stderr)}\n`
+            : "";
+        rl.question(`\n${labelLine}${BOLD}${question}${RESET}\n${descriptionLine}${dim(hint, process.stderr)} `, (answer) => {
             rl.close();
             const trimmed = answer.trim().toLowerCase();
             if (trimmed === "")
@@ -424,6 +437,9 @@ async function publishCompetencies(competencies, opts) {
 }
 // ---------- Main ----------
 export async function runAuditCommand(opts) {
+    if (!opts.json && !opts.quiet) {
+        printBanner();
+    }
     const totalSteps = 4 + (opts.narrate ? 1 : 0) + (opts.publish ? 1 : 0);
     const commandStartedAt = Date.now();
     let resolvedPath = opts.path;
@@ -459,18 +475,39 @@ 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`);
+            }
+        }
+    }
+    // Include all Codex sessions from this machine (user-wide audit)
+    const codexFiles = opts.path ? [] : findCodexSessionFiles();
+    if (codexFiles.length > 0) {
+        sessionFiles = [...sessionFiles, ...codexFiles];
+    }
     if (sessionFiles.length === 0) {
         if (!opts.quiet) {
-            console.error(`[temet] no .jsonl session files found in ${resolvedPath}`);
+            console.error("[temet] no AI session files found on this machine");
         }
         process.exit(1);
     }
-    if (!opts.json && !opts.quiet) {
-        printBanner();
-    }
     if (!opts.quiet) {
-        console.error(`[temet] reading ${sessionFiles.length} saved session file(s)...`);
+        const claudeCount = sessionFiles.length - codexFiles.length;
+        const sources = [
+            claudeCount > 0 ? `${claudeCount} Claude` : "",
+            codexFiles.length > 0 ? `${codexFiles.length} Codex` : "",
+        ]
+            .filter(Boolean)
+            .join(" + ");
+        console.error(`[temet] reading ${sessionFiles.length} session file(s)${sources ? ` (${sources})` : ""}`);
     }
     let completedFiles = 0;
     if (!opts.quiet) {
@@ -602,39 +639,57 @@ export async function runAuditCommand(opts) {
             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();
+            let hookAlreadyInstalled = hookModule.isHookInstalled(settings);
+            const { isMenubarInstalled, installMenubar } = isMacOs()
+                ? await import("./lib/menubar-installer.js")
+                : {
+                    isMenubarInstalled: () => false,
+                    installMenubar: undefined,
+                };
+            const menubarAlreadyInstalled = isMacOs() ? isMenubarInstalled() : false;
+            if (!hookAlreadyInstalled && !opts.track && !hasDeclinedHook()) {
+                const answer = await askYesNo("Want Temet to keep learning from your Claude Code sessions?", true, "Press Enter to continue (or type no to skip):", {
+                    label: "Continuous learning",
+                    description: "Temet will watch for meaningful changes after each session and keep your progress up to date.",
+                });
+                if (answer) {
+                    const binary = hookModule.resolveTemetBinary();
+                    if (binary) {
+                        const updated = hookModule.installHook(settings, binary);
+                        hookModule.writeSettings(settingsPath, updated);
+                        hookAlreadyInstalled = true;
+                        clearHookDeclined();
+                        console.error(`${ok("✓", process.stderr)} Tracking enabled ${dim("Temet will keep an eye on your progress after each session.", process.stderr)}`);
                     }
                 }
+                else {
+                    saveHookDeclined();
+                }
+            }
+            if (!isMacOs()) {
+                if (hookAlreadyInstalled || opts.track) {
+                    console.error(`${ok("✓", process.stderr)} ${dim("Automatic tracking is already on.", process.stderr)}`);
+                }
             }
             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 (!menubarAlreadyInstalled && installMenubar) {
+                    const answer = await askYesNo("Want Temet to stay visible between sessions?", true, "Press Enter to continue (or type no to skip):", {
+                        label: "Stay visible",
+                        description: "Keep your current focus, recent progress, and latest signals one glance away in your menu bar.",
+                    });
                     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)}`);
+                            ? "Temet is open in your menu bar, and automatic tracking is now on."
+                            : "Temet is open in your menu bar.";
+                        console.error(`${ok("✓", process.stderr)} Temet installed ${dim(suffix, process.stderr)}`);
                     }
                 }
+                else if (menubarAlreadyInstalled) {
+                    console.error(`${ok("✓", process.stderr)} ${dim("Temet is already in your menu bar.", process.stderr)}`);
+                }
             }
         }
         catch (error) {

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,10 +13,22 @@ 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
@@ -41,6 +55,7 @@ Advanced:
 
 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
@@ -55,6 +70,10 @@ 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);
 }
@@ -147,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);
     }
@@ -159,6 +181,15 @@ 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,
@@ -511,6 +542,11 @@ 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);

package/dist/lib/diagnostic-runner.js

@@ -1,6 +1,6 @@
 import { basename } from "node:path";
 import { createInterface } from "node:readline";
-import { resolveSessionPath } from "./path-resolver.js";
+import { findCodexSessionFiles, findClaudeProjectCandidates, resolveSessionPath, } from "./path-resolver.js";
 import { trackAuditSnapshot } from "./audit-tracking.js";
 import { findSessionFiles, runAudit, } from "./session-audit.js";
 async function chooseSessionCandidate(candidates) {
@@ -55,12 +55,40 @@ export async function resolveDiagnostics(opts) {
             process.stderr.write(`[temet] using ${label}\n`);
         }
     }
-    const sessionFiles = findSessionFiles(resolvedPath);
+    let sessionFiles = findSessionFiles(resolvedPath);
+    if (sessionFiles.length === 0 && !opts.path && !opts.quiet && !opts.json) {
+        const candidates = findClaudeProjectCandidates();
+        if (candidates.length > 0) {
+            const selected = await chooseSessionCandidate(candidates);
+            if (selected) {
+                resolvedPath = selected.sessionDir;
+                sessionFiles = findSessionFiles(resolvedPath);
+                process.stderr.write(`[temet] using ${selected.label}\n`);
+            }
+        }
+    }
+    const codexFiles = !opts.path ? findCodexSessionFiles() : [];
+    // Include all Codex sessions (user-wide audit)
+    if (!opts.path) {
+        if (codexFiles.length > 0) {
+            sessionFiles = [...sessionFiles, ...codexFiles];
+        }
+    }
     if (sessionFiles.length === 0) {
-        throw new Error(`No .jsonl session files found in ${resolvedPath}.`);
+        throw new Error(opts.path
+            ? `No .jsonl session files found in ${resolvedPath}.`
+            : "No AI session files found on this machine.");
     }
     if (!opts.quiet) {
-        process.stderr.write(`[temet] reading ${sessionFiles.length} saved session file(s)...\n`);
+        const codexCount = codexFiles.length;
+        const claudeCount = sessionFiles.length - codexCount;
+        const sources = [
+            claudeCount > 0 ? `${claudeCount} Claude` : "",
+            codexCount > 0 ? `${codexCount} Codex` : "",
+        ]
+            .filter(Boolean)
+            .join(" + ");
+        process.stderr.write(`[temet] reading ${sessionFiles.length} session file(s)${sources ? ` (${sources})` : ""}\n`);
     }
     const result = await runAudit(sessionFiles);
     let competencies = result.competencies;

package/dist/lib/path-resolver.d.ts

@@ -18,6 +18,14 @@ type ResolveSessionPathOptions = {
 /** 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 type DetectedSources = {
+    claude: boolean;
+    codex: boolean;
+    claudeCount: number;
+    codexCount: number;
+};
+export declare function detectAvailableSources(claudeRoot?: string, codexRoot?: string): DetectedSources;
+export declare function findCodexSessionFiles(codexRoot?: string): string[];
 export declare function findClaudeProjectCandidates(claudeRoot?: string): SessionCandidate[];
 /**
  * Try to read the JSON stdin from a Claude Code hook (non-blocking).

package/dist/lib/path-resolver.js

@@ -2,6 +2,7 @@ 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");
+const DEFAULT_CODEX_ROOT = path.join(homedir(), ".codex");
 /** Convert an absolute project directory to the Claude Code session directory slug. */
 export function cwdToSessionDir(cwd) {
     const slug = path.resolve(cwd).replace(/\//g, "-");
@@ -51,6 +52,51 @@ function candidateFromSessionDir(sessionDir) {
         updatedAtMs,
     };
 }
+export function detectAvailableSources(claudeRoot = DEFAULT_CLAUDE_ROOT, codexRoot = DEFAULT_CODEX_ROOT) {
+    const claudeCandidates = findClaudeProjectCandidates(claudeRoot);
+    const codexFiles = findCodexSessionFiles(codexRoot);
+    return {
+        claude: claudeCandidates.length > 0,
+        codex: codexFiles.length > 0,
+        claudeCount: claudeCandidates.length,
+        codexCount: codexFiles.length,
+    };
+}
+export function findCodexSessionFiles(codexRoot = DEFAULT_CODEX_ROOT) {
+    const files = [];
+    const dirs = [
+        path.join(codexRoot, "sessions"),
+        path.join(codexRoot, "archived_sessions"),
+    ];
+    function walk(dir) {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry);
+            try {
+                const st = statSync(full);
+                if (st.isDirectory()) {
+                    walk(full);
+                }
+                else if (st.isFile() && entry.endsWith(".jsonl")) {
+                    files.push(full);
+                }
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+    for (const dir of dirs) {
+        walk(dir);
+    }
+    return files.sort();
+}
 export function findClaudeProjectCandidates(claudeRoot = DEFAULT_CLAUDE_ROOT) {
     try {
         return readdirSync(claudeRoot)

package/dist/lib/report-writer.js

@@ -80,7 +80,7 @@ export async function saveAuditTextReport(projectLabel, content, now = new Date(
 }
 export async function openReportFile(filePath, platform = process.platform) {
     if (platform === "darwin") {
-        await execFileAsync("open", ["-a", "TextEdit", filePath]);
+        await execFileAsync("open", [filePath]);
         return;
     }
     if (platform === "win32") {

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

@@ -31,5 +31,7 @@ export type SessionStats = {
     toolCalls: ToolCall[];
     filesTouched: string[];
 };
+export type SessionFormat = "claude" | "codex";
+export declare function detectSessionFormat(firstLine: string): SessionFormat;
 export declare function parseSession(filePath: string): AsyncGenerator<SessionMessage>;
 export declare function collectSession(filePath: string): Promise<SessionStats>;

package/dist/lib/session-parser.js

@@ -65,8 +65,71 @@ function extractFilePathsFromToolInput(input) {
     }
     return paths;
 }
-// ---------- Parser ----------
-export async function* parseSession(filePath) {
+// ---------- Codex helpers ----------
+/** Map Codex tool names to normalized equivalents for heuristic extraction. */
+function mapCodexToolName(name) {
+    switch (name) {
+        case "exec_command":
+        case "shell":
+        case "shell_command":
+            return "Bash";
+        case "apply_patch":
+            return "Edit";
+        case "read_file":
+            return "Read";
+        case "write_stdin":
+            return "Bash";
+        case "update_plan":
+            return "TodoWrite";
+        case "view_image":
+            return "Read";
+        default:
+            return name;
+    }
+}
+function parseCodexArguments(raw) {
+    if (typeof raw === "string") {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return {};
+        }
+    }
+    if (raw && typeof raw === "object")
+        return raw;
+    return {};
+}
+function normalizeCodexInput(toolName, args) {
+    if (toolName === "exec_command" ||
+        toolName === "shell" ||
+        toolName === "shell_command") {
+        return { command: args.cmd ?? args.command ?? "" };
+    }
+    if (toolName === "apply_patch") {
+        return {
+            file_path: args.file_path ?? args.path ?? "",
+            old_string: "",
+            new_string: "",
+        };
+    }
+    return args;
+}
+export function detectSessionFormat(firstLine) {
+    try {
+        const entry = JSON.parse(firstLine);
+        if (entry.type === "session_meta")
+            return "codex";
+        if (entry.type === "response_item")
+            return "codex";
+    }
+    catch {
+        // fall through
+    }
+    return "claude";
+}
+// ---------- Parsers ----------
+async function* parseClaudeSession(filePath) {
     const stream = createReadStream(filePath, { encoding: "utf-8" });
     const rl = createInterface({
         input: stream,
@@ -103,6 +166,82 @@ export async function* parseSession(filePath) {
         };
     }
 }
+async function* parseCodexSession(filePath) {
+    const stream = createReadStream(filePath, { encoding: "utf-8" });
+    const rl = createInterface({
+        input: stream,
+        crlfDelay: Number.POSITIVE_INFINITY,
+    });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type !== "response_item")
+            continue;
+        const payload = entry.payload;
+        if (!payload)
+            continue;
+        const ts = entry.timestamp ?? "";
+        // User or assistant text messages
+        if (payload.type === "message") {
+            const role = payload.role;
+            if (role !== "user" && role !== "assistant")
+                continue;
+            const content = normalizeContent(payload.content);
+            if (content.length === 0)
+                continue;
+            yield { uuid: "", timestamp: ts, role, content };
+            continue;
+        }
+        // Function calls → normalize to tool_use
+        if (payload.type === "function_call" && typeof payload.name === "string") {
+            const args = parseCodexArguments(payload.arguments);
+            const mappedName = mapCodexToolName(payload.name);
+            const input = normalizeCodexInput(payload.name, args);
+            yield {
+                uuid: payload.call_id ?? "",
+                timestamp: ts,
+                role: "assistant",
+                content: [
+                    {
+                        type: "tool_use",
+                        id: payload.call_id ?? "",
+                        name: mappedName,
+                        input,
+                    },
+                ],
+            };
+        }
+    }
+}
+export async function* parseSession(filePath) {
+    const stream = createReadStream(filePath, { encoding: "utf-8" });
+    const rl = createInterface({
+        input: stream,
+        crlfDelay: Number.POSITIVE_INFINITY,
+    });
+    let format = null;
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        format = detectSessionFormat(line);
+        break;
+    }
+    // Close the detection stream, re-open with the right parser
+    stream.destroy();
+    if (format === "codex") {
+        yield* parseCodexSession(filePath);
+    }
+    else {
+        yield* parseClaudeSession(filePath);
+    }
+}
 export async function collectSession(filePath) {
     const messages = [];
     const toolCalls = [];

package/package.json

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