@temet/cli 0.3.0 → 0.3.2

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/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,9 @@
+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 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

@@ -0,0 +1,91 @@
+import { execFile } from "node:child_process";
+import { mkdir, readdir, 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 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 });
+    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/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);
+}