@temet/cli 0.3.1 → 0.3.2

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 {};

package/dist/plan.js

@@ -0,0 +1,90 @@
+import { resolveDiagnostics } from "./lib/diagnostic-runner.js";
+import { buildSkillAuditReport } from "./lib/profile-report.js";
+function actionForBlindSpot(title) {
+    switch (title) {
+        case "Feature sprawl":
+            return {
+                title,
+                action: "Finish one live path before opening another new direction this week.",
+                reason: "Your output is not the constraint. Selection and closure are.",
+            };
+        case "Git hygiene under pressure":
+            return {
+                title,
+                action: "Reduce branch churn and land one clean, reviewable slice before the next risky change.",
+                reason: "The skill is there; the failure mode is pressure, not ignorance.",
+            };
+        case "Technical detours":
+            return {
+                title,
+                action: "Timebox deep exploration and force a product decision when the learning curve flattens.",
+                reason: "Curiosity is helping you, but it still needs a stopping rule.",
+            };
+        case "Coordination drag":
+            return {
+                title,
+                action: "Write the one-line decision and owner before you expand the system further.",
+                reason: "Alignment cost is starting to compete with build cost.",
+            };
+        default:
+            return {
+                title,
+                action: "Keep the loop short and choose one concrete improvement to test next.",
+                reason: "The report points to a leverage point, not a reason to add more layers.",
+            };
+    }
+}
+function buildPlanItems(blindSpots, meaningfulChanges) {
+    const items = blindSpots
+        .slice(0, 3)
+        .map((spot) => actionForBlindSpot(spot.title));
+    if (meaningfulChanges.length > 0) {
+        items.push({
+            title: "Recent movement",
+            action: "Protect the newest positive change and turn it into a repeated habit.",
+            reason: meaningfulChanges[0] ?? "A new pattern just surfaced; reinforce it.",
+        });
+    }
+    return items.slice(0, 3);
+}
+export function buildPlanJsonOutput(input) {
+    return input;
+}
+function printPlan(output) {
+    console.log("PLAN");
+    console.log("");
+    console.log(output.professionalDna);
+    console.log("");
+    console.log("Keep");
+    for (const item of output.keep) {
+        console.log(`  - ${item.title}${item.tagline ? ` — ${item.tagline}` : ""}`);
+    }
+    console.log("");
+    console.log("Watch");
+    for (const item of output.watch) {
+        console.log(`  - ${item.title}: ${item.body}`);
+    }
+    console.log("");
+    console.log("Plan");
+    for (const item of output.plan) {
+        console.log(`  - ${item.action}`);
+        console.log(`    Why: ${item.reason}`);
+    }
+}
+export async function runPlanCommand(opts) {
+    const diagnostics = await resolveDiagnostics(opts);
+    if (opts.quiet)
+        return;
+    const report = buildSkillAuditReport(diagnostics.result, diagnostics.competencies, diagnostics.tracking);
+    const output = buildPlanJsonOutput({
+        professionalDna: diagnostics.bilan?.trim() || report.professionalDna,
+        keep: report.tacitSkills.slice(0, 3),
+        watch: report.blindSpots.slice(0, 3),
+        plan: buildPlanItems(report.blindSpots, report.meaningfulChanges),
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    printPlan(output);
+}

package/dist/traces.d.ts

@@ -0,0 +1,41 @@
+import type { AuditCliOptions } from "./lib/cli-args.js";
+import type { CompetencyEntry } from "./lib/types.js";
+type EvidenceItem = {
+    kind: "example" | "decision" | "anti_pattern" | "mentor";
+    text: string;
+};
+export declare function buildTracesJsonOutput(input: {
+    projectLabel: string;
+    sessions: number;
+    prompts: number;
+    toolCalls: number;
+    competencies: CompetencyEntry[];
+    workflows: Array<{
+        description: string;
+        sequence: string[];
+        occurrences: number;
+        sessions: number;
+        confidence: number;
+    }>;
+}): {
+    project: string;
+    sessions: number;
+    prompts: number;
+    toolCalls: number;
+    competencies: {
+        name: string;
+        category: import("./lib/types.js").CompetencyCategory;
+        proficiencyLevel: import("./lib/types.js").ProficiencyLevel;
+        description: string;
+        evidence: EvidenceItem[];
+    }[];
+    workflows: {
+        description: string;
+        sequence: string[];
+        occurrences: number;
+        sessions: number;
+        confidence: number;
+    }[];
+};
+export declare function runTracesCommand(opts: AuditCliOptions): Promise<void>;
+export {};