@temet/cli 0.3.1 → 0.3.3

package/dist/lib/diagnostic-runner.js

@@ -0,0 +1,106 @@
+import { basename } from "node:path";
+import { createInterface } from "node:readline";
+import { findClaudeProjectCandidates, resolveSessionPath, } from "./path-resolver.js";
+import { trackAuditSnapshot } from "./audit-tracking.js";
+import { findSessionFiles, runAudit, } from "./session-audit.js";
+async function chooseSessionCandidate(candidates) {
+    if (!process.stdin.isTTY || candidates.length === 0)
+        return null;
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    process.stderr.write(`\n[temet] I found ${candidates.length} Claude Code projects with session history. Pick one to inspect.\n\n`);
+    candidates.slice(0, 9).forEach((candidate, index) => {
+        process.stderr.write(`  ${index + 1}. ${candidate.label}${index === 0 ? "  (most recent)" : ""}\n`);
+    });
+    process.stderr.write("\n");
+    return new Promise((resolve) => {
+        rl.question("[temet] Choose 1-9, or press Enter for the most recent project: ", (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            if (!trimmed) {
+                resolve(candidates[0] ?? null);
+                return;
+            }
+            const index = Number.parseInt(trimmed, 10) - 1;
+            if (!Number.isFinite(index) ||
+                index < 0 ||
+                index >= candidates.length) {
+                resolve(candidates[0] ?? null);
+                return;
+            }
+            resolve(candidates[index] ?? null);
+        });
+    });
+}
+export async function resolveDiagnostics(opts) {
+    const resolution = resolveSessionPath(opts.path || undefined, process.env);
+    if (!resolution.path) {
+        throw new Error("No Claude Code sessions found here. Run this command from a project folder, or use --path <session-dir>.");
+    }
+    let resolvedPath = resolution.path;
+    if (!opts.path &&
+        !opts.json &&
+        !opts.quiet &&
+        resolution.source === "recent" &&
+        resolution.candidates.length > 1) {
+        const selected = await chooseSessionCandidate(resolution.candidates);
+        resolvedPath = selected?.sessionDir ?? resolution.path;
+        const label = selected?.label ?? resolution.candidates[0]?.label;
+        if (label) {
+            process.stderr.write(`[temet] using ${label}\n`);
+        }
+    }
+    else {
+        const label = resolution.candidates[0]?.label;
+        if (label && resolution.source !== "explicit" && !opts.quiet) {
+            process.stderr.write(`[temet] using ${label}\n`);
+        }
+    }
+    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`);
+            }
+        }
+    }
+    if (sessionFiles.length === 0) {
+        throw new Error(`No .jsonl session files found in ${resolvedPath}.`);
+    }
+    if (!opts.quiet) {
+        process.stderr.write(`[temet] reading ${sessionFiles.length} saved session file(s)...\n`);
+    }
+    const result = await runAudit(sessionFiles);
+    let competencies = result.competencies;
+    let bilan;
+    if (opts.narrate && !opts.quiet) {
+        try {
+            const narratorModule = await import("./narrator-lite.js");
+            if (narratorModule.resolveAuth()) {
+                const narrated = await narratorModule.narrateCompetencies(competencies, result.combined, result.workflows, { model: opts.model || undefined });
+                competencies = narrated.competencies;
+                bilan = narrated.bilan || undefined;
+            }
+        }
+        catch {
+            // Keep deterministic fallback if narration fails.
+        }
+    }
+    let tracking;
+    if (opts.track) {
+        tracking = await trackAuditSnapshot(resolvedPath, result, competencies);
+    }
+    return {
+        resolvedPath,
+        result,
+        competencies,
+        bilan,
+        tracking,
+    };
+}
+export function defaultProjectLabel(resolvedPath) {
+    return basename(resolvedPath);
+}

package/dist/lib/menubar-installer.d.ts

@@ -0,0 +1,19 @@
+export declare const TEMET_BAR_APP_NAME = "Temet.app";
+export type MenubarInstallResult = {
+    appPath: string;
+    configPath: string;
+    hookInstalled: boolean;
+};
+export declare function getMenubarAppPath(): string;
+export declare function isMenubarInstalled(): boolean;
+export declare function getMenubarAssetPath(): string;
+export declare function installMenubar(options?: {
+    dryRun?: boolean;
+    ensureHook?: boolean;
+}): Promise<MenubarInstallResult>;
+export declare function uninstallMenubar(options?: {
+    dryRun?: boolean;
+}): Promise<{
+    appPath: string;
+    configPath: string;
+}>;

package/dist/lib/menubar-installer.js

@@ -0,0 +1,99 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { getSettingsPath, installHook, isHookInstalled, readSettings, resolveTemetBinary, writeSettings, } from "./hook-installer.js";
+import { getMenubarConfigPath, writeMenubarConfig } from "./menubar-state.js";
+const execFileAsync = promisify(execFile);
+export const TEMET_BAR_APP_NAME = "Temet.app";
+function findCliPackageRoot() {
+    let current = path.dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        const packageJson = path.join(current, "package.json");
+        if (existsSync(packageJson)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error("Could not resolve @temet/cli package root.");
+        }
+        current = parent;
+    }
+}
+export function getMenubarAppPath() {
+    return path.join(homedir(), "Applications", TEMET_BAR_APP_NAME);
+}
+export function isMenubarInstalled() {
+    return existsSync(getMenubarAppPath());
+}
+export function getMenubarAssetPath() {
+    return path.join(findCliPackageRoot(), "assets", "macos", "Temet.app.zip");
+}
+async function bestEffortClearQuarantine(appPath) {
+    try {
+        await execFileAsync("xattr", ["-d", "com.apple.quarantine", appPath]);
+    }
+    catch {
+        // Best effort only.
+    }
+}
+export async function installMenubar(options) {
+    if (process.platform !== "darwin") {
+        throw new Error("Temet is only available in the macOS menu bar.");
+    }
+    const assetPath = getMenubarAssetPath();
+    if (!existsSync(assetPath)) {
+        throw new Error(`Missing Temet.app.zip in ${assetPath}. Build and package the menu bar app first.`);
+    }
+    const binary = resolveTemetBinary();
+    if (!binary) {
+        throw new Error("Could not resolve the temet binary. Install @temet/cli globally first.");
+    }
+    const appPath = getMenubarAppPath();
+    const configPath = getMenubarConfigPath();
+    let hookInstalled = false;
+    if (options?.dryRun) {
+        return { appPath, configPath, hookInstalled: options.ensureHook === true };
+    }
+    await mkdir(path.dirname(appPath), { recursive: true });
+    await rm(appPath, { recursive: true, force: true });
+    await execFileAsync("unzip", ["-oq", assetPath, "-d", path.dirname(appPath)]);
+    await writeMenubarConfig(binary);
+    if (options?.ensureHook) {
+        const settingsPath = getSettingsPath();
+        const settings = readSettings(settingsPath);
+        if (!isHookInstalled(settings)) {
+            const updated = installHook(settings, binary);
+            writeSettings(settingsPath, updated);
+            hookInstalled = true;
+        }
+    }
+    await bestEffortClearQuarantine(appPath);
+    try {
+        await execFileAsync("open", [appPath]);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Temet was installed but macOS refused to open it automatically. Open ${appPath} manually. Details: ${message}`);
+    }
+    return { appPath, configPath, hookInstalled };
+}
+export async function uninstallMenubar(options) {
+    const appPath = getMenubarAppPath();
+    const configPath = getMenubarConfigPath();
+    if (options?.dryRun) {
+        return { appPath, configPath };
+    }
+    try {
+        await execFileAsync("pkill", ["-f", "Temet.app"]);
+    }
+    catch {
+        // App may not be running.
+    }
+    await rm(appPath, { recursive: true, force: true });
+    await rm(configPath, { force: true });
+    return { appPath, configPath };
+}

package/dist/lib/menubar-state.d.ts

@@ -0,0 +1,78 @@
+import { type TrackingResult } from "./audit-tracking.js";
+import type { AuditResult } from "./session-audit.js";
+import type { CompetencyEntry, ProficiencyLevel } from "./types.js";
+export type MenubarSuperpower = {
+    title: string;
+    level: ProficiencyLevel;
+    evidenceCount: number;
+};
+export type MenubarWatch = {
+    title: string;
+    body: string;
+};
+export type CurrentFocusStatus = "active" | "improving" | "missed" | "completed" | "replaced";
+export type CurrentFocusCheck = "followed" | "not_followed" | "insufficient_signal";
+export type MenubarCurrentFocus = {
+    title: string;
+    reason: string;
+    startedAt: string;
+    durationDays: number;
+    status: CurrentFocusStatus;
+    lastCheck: CurrentFocusCheck;
+    streak: number;
+};
+export type MenubarMetrics = {
+    sessions: number;
+    prompts: number;
+    toolCalls: number;
+    workflows: number;
+};
+export type MenubarProgress = {
+    summary: string;
+    reinforced: string;
+    watch: string;
+    new: string;
+    next: string;
+    notificationTitle: string;
+    notificationBody: string;
+};
+export type TemetMenubarState = {
+    version: 1;
+    projectKey: string;
+    projectLabel: string;
+    createdAt: string;
+    trackingInstalled: boolean;
+    metrics: MenubarMetrics;
+    dna: string;
+    superpower: MenubarSuperpower;
+    watch: MenubarWatch;
+    progress: MenubarProgress;
+    recentChange: string;
+    currentFocus: MenubarCurrentFocus;
+    lastReportPath: string | null;
+    sourcePath: string;
+};
+export type MenubarConfig = {
+    version: 1;
+    temetBinary: string;
+};
+type BuildMenubarStateInput = {
+    sourcePath: string;
+    result: Pick<AuditResult, "sessionCount" | "promptCount" | "messageCount" | "toolCallCount" | "workflowCount" | "workflows" | "signals">;
+    competencies: CompetencyEntry[];
+    bilan?: string;
+    tracking?: TrackingResult;
+    trackingInstalled: boolean;
+    lastReportPath?: string | null;
+    previousState?: TemetMenubarState | null;
+};
+export declare function getMenubarStatePath(): string;
+export declare function getMenubarConfigPath(): string;
+export declare function buildMenubarState(input: BuildMenubarStateInput): TemetMenubarState;
+export declare function loadMenubarState(): Promise<TemetMenubarState | null>;
+export declare function writeMenubarState(input: BuildMenubarStateInput): Promise<TemetMenubarState>;
+export declare function loadMenubarConfig(): Promise<MenubarConfig | null>;
+export declare function writeMenubarConfig(temetBinary: string): Promise<MenubarConfig>;
+export declare function isMenubarConfigPresent(): boolean;
+export declare function resolveLastReportPath(projectLabel: string): Promise<string | null>;
+export {};

package/dist/lib/menubar-state.js

@@ -0,0 +1,275 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { buildAuditSnapshot, } from "./audit-tracking.js";
+import { buildSkillAuditReport, } from "./profile-report.js";
+import { findLatestReportPath } from "./report-writer.js";
+const PROFICIENCY_SCORE = {
+    novice: 1,
+    advanced_beginner: 2,
+    competent: 3,
+    proficient: 4,
+    expert: 5,
+};
+function getTemetRoot() {
+    return path.join(homedir(), ".temet");
+}
+function getMenubarRoot() {
+    return path.join(getTemetRoot(), "menubar");
+}
+export function getMenubarStatePath() {
+    return path.join(getMenubarRoot(), "latest.json");
+}
+export function getMenubarConfigPath() {
+    return path.join(getMenubarRoot(), "config.json");
+}
+function evidenceCount(entry) {
+    return (entry.evidence.examples.length +
+        entry.evidence.decisionCriteria.length +
+        entry.evidence.antiPatterns.length +
+        entry.evidence.mentorAdvice.length);
+}
+function pickTopCompetency(competencies) {
+    return [...competencies].sort((a, b) => {
+        const scoreA = PROFICIENCY_SCORE[a.proficiencyLevel] * 10 + evidenceCount(a);
+        const scoreB = PROFICIENCY_SCORE[b.proficiencyLevel] * 10 + evidenceCount(b);
+        if (scoreA !== scoreB)
+            return scoreB - scoreA;
+        return a.name.localeCompare(b.name);
+    })[0];
+}
+function firstSentence(value) {
+    const trimmed = value.replace(/\s+/g, " ").trim();
+    if (!trimmed)
+        return "";
+    const match = trimmed.match(/^(.+?[.!?])(?:\s|$)/);
+    return (match?.[1] ?? trimmed).trim();
+}
+function sanitizeLine(value, fallback) {
+    const trimmed = value.replace(/\s+/g, " ").trim();
+    return trimmed.length > 0 ? trimmed : fallback;
+}
+function trimPreview(value, maxLength) {
+    const normalized = sanitizeLine(value, "");
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, maxLength).trimEnd()}...`;
+}
+function humanizeChange(change) {
+    switch (change.type) {
+        case "new_skill":
+            return change.title.replace(/^New skill surfaced:\s*/i, "New skill: ");
+        case "new_workflow":
+            return "A new workflow signal surfaced";
+        case "level_up":
+            return change.title.replace(/\s*moved up$/i, " is strengthening");
+        case "level_down":
+            return change.title.replace(/\s*moved down$/i, " needs attention");
+        case "baseline":
+            return "Tracking baseline created";
+    }
+}
+function selectCurrentFocusTemplate(watch) {
+    switch (watch.title) {
+        case "Feature sprawl":
+            return {
+                title: "Validate demand before adding product surface",
+                reason: firstSentence(watch.body),
+                durationDays: 7,
+            };
+        case "Git hygiene under pressure":
+            return {
+                title: "Tighten git hygiene before pushing",
+                reason: firstSentence(watch.body),
+                durationDays: 7,
+            };
+        case "Technical detours":
+            return {
+                title: "Stop exploration once product value flattens",
+                reason: firstSentence(watch.body),
+                durationDays: 7,
+            };
+        case "Coordination drag":
+            return {
+                title: "Name the next decision before expanding scope",
+                reason: firstSentence(watch.body),
+                durationDays: 7,
+            };
+        default:
+            return {
+                title: `Address ${watch.title.toLowerCase()}`,
+                reason: firstSentence(watch.body),
+                durationDays: 7,
+            };
+    }
+}
+function evaluateCurrentFocus(watch, createdAt, previousState) {
+    const template = selectCurrentFocusTemplate(watch);
+    if (!previousState) {
+        return {
+            ...template,
+            startedAt: createdAt,
+            status: "active",
+            lastCheck: "insufficient_signal",
+            streak: 0,
+        };
+    }
+    if (previousState.currentFocus.title !== template.title) {
+        return {
+            ...template,
+            startedAt: createdAt,
+            status: "active",
+            lastCheck: "insufficient_signal",
+            streak: 0,
+        };
+    }
+    return {
+        ...template,
+        startedAt: previousState.currentFocus.startedAt,
+        status: "active",
+        lastCheck: "insufficient_signal",
+        streak: 0,
+    };
+}
+function buildProgress(currentFocus, watch, changes, previousState) {
+    const meaningfulChanges = changes.filter((change) => change.type !== "baseline");
+    const firstMeaningful = meaningfulChanges[0];
+    const isNewFocus = previousState?.currentFocus.title != null &&
+        previousState.currentFocus.title !== currentFocus.title;
+    const humanizedSignal = firstMeaningful
+        ? humanizeChange(firstMeaningful)
+        : null;
+    const reinforced = currentFocus.lastCheck === "followed"
+        ? currentFocus.title
+        : (humanizedSignal ?? currentFocus.title);
+    const watchLine = currentFocus.lastCheck === "not_followed"
+        ? "Last session drifted away from this focus."
+        : firstSentence(watch.body);
+    const newSignal = humanizedSignal ?? "No new signal surfaced yet";
+    const next = "Open plan to review the operating adjustment.";
+    let summary = "Set today. Temet will start checking this focus after your next tracked session.";
+    if (isNewFocus) {
+        summary = `New focus: ${currentFocus.title}.`;
+    }
+    else if (currentFocus.lastCheck === "not_followed") {
+        summary = `Last session pulled away from ${currentFocus.title.toLowerCase()}.`;
+    }
+    else if (currentFocus.lastCheck === "followed") {
+        summary = `${currentFocus.title} showed up in your last session.`;
+    }
+    else if (previousState?.currentFocus.title === currentFocus.title) {
+        summary =
+            "Still active. Temet is calibrating this focus from your next tracked sessions.";
+    }
+    const notificationBody = [
+        summary,
+        watchLine,
+        firstMeaningful ? `New signal: ${newSignal}.` : null,
+    ]
+        .filter(Boolean)
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+    return {
+        summary,
+        reinforced,
+        watch: watchLine,
+        new: newSignal,
+        next,
+        notificationTitle: "Temet update",
+        notificationBody,
+    };
+}
+export function buildMenubarState(input) {
+    const snapshot = input.tracking?.current ??
+        buildAuditSnapshot(input.sourcePath, input.result, input.competencies);
+    const report = buildSkillAuditReport(input.result, input.competencies, input.tracking);
+    const watchSection = report.blindSpots[0] ??
+        {
+            title: "No watch item computed yet",
+            body: "Run more tracked audits to surface a stable watch item.",
+        };
+    const topCompetency = pickTopCompetency(input.competencies);
+    const watch = {
+        title: watchSection.title,
+        body: sanitizeLine(watchSection.body, "No watch item computed yet."),
+    };
+    const currentFocus = evaluateCurrentFocus(watch, snapshot.createdAt, input.previousState?.projectKey === snapshot.projectKey
+        ? input.previousState
+        : null);
+    const progress = buildProgress(currentFocus, watch, input.tracking?.changes ?? [], input.previousState?.projectKey === snapshot.projectKey
+        ? input.previousState
+        : null);
+    const latestMeaningfulChange = input.tracking?.changes.find((change) => change.type !== "baseline");
+    return {
+        version: 1,
+        projectKey: snapshot.projectKey,
+        projectLabel: snapshot.projectLabel,
+        createdAt: snapshot.createdAt,
+        trackingInstalled: input.trackingInstalled,
+        metrics: {
+            sessions: snapshot.sessions,
+            prompts: input.result.promptCount,
+            toolCalls: snapshot.toolCalls,
+            workflows: input.result.workflowCount,
+        },
+        dna: sanitizeLine(input.bilan?.trim() || report.professionalDna, "No professional DNA available yet."),
+        superpower: {
+            title: topCompetency?.name ??
+                report.tacitSkills[0]?.title ??
+                "No superpower yet",
+            level: topCompetency?.proficiencyLevel ?? "novice",
+            evidenceCount: topCompetency ? evidenceCount(topCompetency) : 0,
+        },
+        watch,
+        progress,
+        recentChange: latestMeaningfulChange
+            ? humanizeChange(latestMeaningfulChange)
+            : "No new signal surfaced yet.",
+        currentFocus,
+        lastReportPath: input.lastReportPath ?? null,
+        sourcePath: snapshot.sourcePath,
+    };
+}
+export async function loadMenubarState() {
+    try {
+        const raw = await readFile(getMenubarStatePath(), "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed?.version === 1 ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeMenubarState(input) {
+    const state = buildMenubarState(input);
+    await mkdir(getMenubarRoot(), { recursive: true });
+    await writeFile(getMenubarStatePath(), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+    return state;
+}
+export async function loadMenubarConfig() {
+    try {
+        const raw = await readFile(getMenubarConfigPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed?.version === 1 && parsed.temetBinary ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeMenubarConfig(temetBinary) {
+    await mkdir(getMenubarRoot(), { recursive: true });
+    const payload = {
+        version: 1,
+        temetBinary,
+    };
+    await writeFile(getMenubarConfigPath(), `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    return payload;
+}
+export function isMenubarConfigPresent() {
+    return existsSync(getMenubarConfigPath());
+}
+export async function resolveLastReportPath(projectLabel) {
+    return findLatestReportPath(projectLabel);
+}

package/dist/lib/notifier.d.ts

@@ -1,9 +1,11 @@
 import type { AuditChange } from "./audit-tracking.js";
+import type { MenubarProgress } from "./menubar-state.js";
 export type NotificationPayload = {
     title: string;
     body: string;
 };
 /** Build the notification text from audit changes. Returns null if nothing to notify. */
 export declare function formatNotification(changes: AuditChange[], projectLabel: string): NotificationPayload | null;
+export declare function formatProgressNotification(progress: MenubarProgress | null | undefined): NotificationPayload | null;
 /** Send a native OS notification. Fire-and-forget. */
 export declare function sendNotification(payload: NotificationPayload): Promise<void>;

package/dist/lib/notifier.js

@@ -23,6 +23,17 @@ export function formatNotification(changes, projectLabel) {
         : `${first.title} and ${meaningful.length - 1} more`;
     return { title: "Temet", body };
 }
+export function formatProgressNotification(progress) {
+    if (!progress)
+        return null;
+    const body = progress.notificationBody?.trim();
+    if (!body)
+        return null;
+    return {
+        title: progress.notificationTitle || "Temet update",
+        body,
+    };
+}
 /** Send a native OS notification. Fire-and-forget. */
 export async function sendNotification(payload) {
     const { title, body } = payload;

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

@@ -3,5 +3,7 @@ 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 getReportDirectory(projectLabel: string): string;
+export declare function findLatestReportPath(projectLabel: string): Promise<string | null>;
 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

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
@@ -54,6 +54,24 @@ export function buildReportPath(projectLabel, now = new Date()) {
     const safeLabel = projectLabel.replace(/[^a-zA-Z0-9._-]+/g, "-");
     return path.join(homedir(), ".temet", "reports", safeLabel, `temet-skills-audit-${date}.txt`);
 }
+export function getReportDirectory(projectLabel) {
+    const safeLabel = projectLabel.replace(/[^a-zA-Z0-9._-]+/g, "-");
+    return path.join(homedir(), ".temet", "reports", safeLabel);
+}
+export async function findLatestReportPath(projectLabel) {
+    const dir = getReportDirectory(projectLabel);
+    try {
+        const entries = await readdir(dir);
+        const latest = entries
+            .filter((entry) => entry.endsWith(".txt"))
+            .sort()
+            .at(-1);
+        return latest ? path.join(dir, latest) : null;
+    }
+    catch {
+        return null;
+    }
+}
 export async function saveAuditTextReport(projectLabel, content, now = new Date()) {
     const filePath = buildReportPath(projectLabel, now);
     await mkdir(path.dirname(filePath), { recursive: true });

package/dist/plan.d.ts

@@ -0,0 +1,33 @@
+import type { AuditCliOptions } from "./lib/cli-args.js";
+type PlanItem = {
+    title: string;
+    action: string;
+    reason: string;
+};
+export declare function buildPlanJsonOutput(input: {
+    professionalDna: string;
+    keep: Array<{
+        title: string;
+        tagline?: string;
+        body: string;
+    }>;
+    watch: Array<{
+        title: string;
+        body: string;
+    }>;
+    plan: PlanItem[];
+}): {
+    professionalDna: string;
+    keep: Array<{
+        title: string;
+        tagline?: string;
+        body: string;
+    }>;
+    watch: Array<{
+        title: string;
+        body: string;
+    }>;
+    plan: PlanItem[];
+};
+export declare function runPlanCommand(opts: AuditCliOptions): Promise<void>;
+export {};