/** * RSI Lifecycle — Usage tracking and lifecycle management for learned skills. * * - Tracks usage count per learned skill * - Archives skills with 0 uses after 30 days * - Flags high performers (>10 uses) for potential promotion */ import path from "path"import fs from "fs/promises"import { Global } from "@/global"import { Log } from "@/util/log" export namespace RSILifecycle {  const log = Log.create({ service: "rsi-lifecycle" })  const LEARNED_SKILLS_DIR = path.join(Global.Path.data, "learned-skills")  const STATS_PATH = path.join(LEARNED_SKILLS_DIR, ".stats.json")  const ARCHIVE_AFTER_DAYS = 30  const HIGH_PERFORMER_THRESHOLD = 10   interface Stats {    skills: Record<string, SkillStats>  }   interface SkillStats {    usageCount: number    firstUsed: number    lastUsed: number    created: number  }   async function readStats(): Promise<Stats> {    try {      return await Bun.file(STATS_PATH).json()    } catch {      return { skills: {} }    }  }   async function writeStats(stats: Stats): Promise<void> {    await fs.mkdir(path.dirname(STATS_PATH), { recursive: true })    await Bun.write(STATS_PATH, JSON.stringify(stats, null, 2))  }   /** Increment usage count for a learned skill. */  export async function trackUsage(skillName: string): Promise<void> {    const stats = await readStats()    const now = Date.now()    if (!stats.skills[skillName]) {      stats.skills[skillName] = {        usageCount: 0,        firstUsed: now,        lastUsed: now,        created: now,      }    }    stats.skills[skillName].usageCount++    stats.skills[skillName].lastUsed = now    await writeStats(stats)  }   /** Register a newly created learned skill in stats. */  export async function registerSkill(skillName: string): Promise<void> {    const stats = await readStats()    if (!stats.skills[skillName]) {      const now = Date.now()      stats.skills[skillName] = {        usageCount: 0,        firstUsed: 0,        lastUsed: 0,        created: now,      }      await writeStats(stats)    }  }   /** Get stats for a skill. */  export async function getStats(skillName: string): Promise<SkillStats | null> {    const stats = await readStats()    return stats.skills[skillName] ?? null  }   /** Archive unused skills (0 uses after ARCHIVE_AFTER_DAYS). Returns archived count. */  export async function archiveUnused(): Promise<number> {    const stats = await readStats()    const now = Date.now()    const threshold = ARCHIVE_AFTER_DAYS * 24 * 60 * 60 * 1000    let archived = 0     for (const [name, s] of Object.entries(stats.skills)) {      if (s.usageCount === 0 && now - s.created > threshold) {        const dir = path.join(LEARNED_SKILLS_DIR, name)        const exists = await fs.stat(dir).catch(() => null)        if (exists) {          await fs.rm(dir, { recursive: true })          delete stats.skills[name]          archived++          log.info("archived unused learned skill", { name, age: Math.round((now - s.created) / 86400000) })        }      }    }     if (archived > 0) {      await writeStats(stats)    }    return archived  }   /** Find high-performing skills (>HIGH_PERFORMER_THRESHOLD uses). */  export async function highPerformers(): Promise<string[]> {    const stats = await readStats()    return Object.entries(stats.skills)      .filter(([, s]) => s.usageCount > HIGH_PERFORMER_THRESHOLD)      .map(([name]) => name)  }   /** Startup lifecycle check — archive unused, log high performers. */  export async function startupCheck(): Promise<void> {    try {      const archived = await archiveUnused()      if (archived > 0) {        log.info("startup: archived unused learned skills", { count: archived })      }       const performers = await highPerformers()      if (performers.length > 0) {        log.info("startup: high-performing learned skills", { skills: performers })      }    } catch (e) {      log.warn("lifecycle startup check failed", { error: e instanceof Error ? e.message : String(e) })    }  }}