@ekkos/cli 0.2.8 → 0.2.10

package/dist/utils/paths.d.ts

@@ -0,0 +1,125 @@
+/**
+ * ekkOS Path Utilities - Instance-Aware Path Resolution
+ *
+ * Per ekkOS Onboarding Spec v1.2 FINAL + ADDENDUM:
+ * - All Tier 0 cache paths MUST be: ~/.ekkos/cache/sessions/{instanceId}/{sessionId}.jsonl
+ * - All persisted records MUST include: instanceId, sessionId, sessionName
+ *
+ * This module provides canonical path helpers for the entire CLI.
+ */
+export declare const DEFAULT_INSTANCE_ID = "default";
+/**
+ * Normalize instanceId - use 'default' if empty/undefined
+ */
+export declare function normalizeInstanceId(instanceId?: string | null): string;
+/**
+ * Get the base ekkOS config directory
+ * ~/.ekkos on Unix, %USERPROFILE%\.ekkos on Windows
+ */
+export declare function getConfigDir(): string;
+/**
+ * Get the cache directory
+ * ~/.ekkos/cache
+ */
+export declare function getCacheDir(): string;
+/**
+ * Get the sessions cache directory
+ * ~/.ekkos/cache/sessions
+ */
+export declare function getSessionsDir(): string;
+/**
+ * Get the instance-scoped sessions directory
+ * ~/.ekkos/cache/sessions/{instanceId}
+ */
+export declare function getInstanceSessionsDir(instanceId?: string | null): string;
+/**
+ * Get the path to a session's turns JSONL file (instance-scoped)
+ * ~/.ekkos/cache/sessions/{instanceId}/{sessionId}.jsonl
+ */
+export declare function getTurnsPath(instanceId: string | null | undefined, sessionId: string): string;
+/**
+ * Get the path to a session's metadata file (instance-scoped)
+ * ~/.ekkos/cache/sessions/{instanceId}/{sessionId}.meta.json
+ */
+export declare function getMetaPath(instanceId: string | null | undefined, sessionId: string): string;
+/**
+ * Get the path to a session's stream log file (instance-scoped)
+ * ~/.ekkos/cache/sessions/{instanceId}/{sessionId}.stream.jsonl
+ */
+export declare function getStreamLogPath(instanceId: string | null | undefined, sessionId: string): string;
+/**
+ * Get the path to a session's state file (instance-scoped)
+ * ~/.ekkos/cache/sessions/{instanceId}/{sessionId}.state.json
+ */
+export declare function getStreamStatePath(instanceId: string | null | undefined, sessionId: string): string;
+/**
+ * Get the path to the session index file (instance-scoped)
+ * ~/.ekkos/cache/sessions/{instanceId}/index.json
+ */
+export declare function getIndexPath(instanceId?: string | null): string;
+/**
+ * Get the instances directory
+ * ~/.ekkos/instances
+ */
+export declare function getInstancesDir(): string;
+/**
+ * Get the path to an instance file
+ * ~/.ekkos/instances/{instanceId}.json
+ */
+export declare function getInstanceFilePath(instanceId: string): string;
+/**
+ * Legacy path for backward compatibility (read-only fallback)
+ * ~/.ekkos/cache/sessions/{sessionId}.jsonl
+ */
+export declare function getLegacyTurnsPath(sessionId: string): string;
+/**
+ * Legacy metadata path for backward compatibility (read-only fallback)
+ * ~/.ekkos/cache/sessions/{sessionId}.meta.json
+ */
+export declare function getLegacyMetaPath(sessionId: string): string;
+/**
+ * Legacy stream log path for backward compatibility (read-only fallback)
+ * ~/.ekkos/cache/sessions/{sessionId}.stream.jsonl
+ */
+export declare function getLegacyStreamLogPath(sessionId: string): string;
+/**
+ * Ensure a directory exists (mkdirp)
+ */
+export declare function ensureDir(dirPath: string): void;
+/**
+ * Ensure the instance sessions directory exists
+ */
+export declare function ensureInstanceDir(instanceId?: string | null): string;
+/**
+ * Ensure the base ekkOS directories exist
+ */
+export declare function ensureBaseDirs(): void;
+/**
+ * List all instance directories under sessions cache
+ * Returns array of instanceIds
+ */
+export declare function listInstanceIds(): string[];
+/**
+ * Check if a file exists at the instance-scoped path
+ * If not, check legacy path and return which one exists (if any)
+ */
+export declare function findTurnsFile(instanceId: string | null | undefined, sessionId: string): {
+    path: string;
+    isLegacy: boolean;
+} | null;
+/**
+ * Check if a meta file exists at the instance-scoped path
+ * If not, check legacy path and return which one exists (if any)
+ */
+export declare function findMetaFile(instanceId: string | null | undefined, sessionId: string): {
+    path: string;
+    isLegacy: boolean;
+} | null;
+/**
+ * Check if a stream log exists at the instance-scoped path
+ * If not, check legacy path and return which one exists (if any)
+ */
+export declare function findStreamLogFile(instanceId: string | null | undefined, sessionId: string): {
+    path: string;
+    isLegacy: boolean;
+} | null;

package/dist/utils/paths.js

@@ -0,0 +1,283 @@
+"use strict";
+/**
+ * ekkOS Path Utilities - Instance-Aware Path Resolution
+ *
+ * Per ekkOS Onboarding Spec v1.2 FINAL + ADDENDUM:
+ * - All Tier 0 cache paths MUST be: ~/.ekkos/cache/sessions/{instanceId}/{sessionId}.jsonl
+ * - All persisted records MUST include: instanceId, sessionId, sessionName
+ *
+ * This module provides canonical path helpers for the entire CLI.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_INSTANCE_ID = void 0;
+exports.normalizeInstanceId = normalizeInstanceId;
+exports.getConfigDir = getConfigDir;
+exports.getCacheDir = getCacheDir;
+exports.getSessionsDir = getSessionsDir;
+exports.getInstanceSessionsDir = getInstanceSessionsDir;
+exports.getTurnsPath = getTurnsPath;
+exports.getMetaPath = getMetaPath;
+exports.getStreamLogPath = getStreamLogPath;
+exports.getStreamStatePath = getStreamStatePath;
+exports.getIndexPath = getIndexPath;
+exports.getInstancesDir = getInstancesDir;
+exports.getInstanceFilePath = getInstanceFilePath;
+exports.getLegacyTurnsPath = getLegacyTurnsPath;
+exports.getLegacyMetaPath = getLegacyMetaPath;
+exports.getLegacyStreamLogPath = getLegacyStreamLogPath;
+exports.ensureDir = ensureDir;
+exports.ensureInstanceDir = ensureInstanceDir;
+exports.ensureBaseDirs = ensureBaseDirs;
+exports.listInstanceIds = listInstanceIds;
+exports.findTurnsFile = findTurnsFile;
+exports.findMetaFile = findMetaFile;
+exports.findStreamLogFile = findStreamLogFile;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+// Base directories
+const HOME = os.homedir();
+const EKKOS_DIR = path.join(HOME, '.ekkos');
+const CACHE_DIR = path.join(EKKOS_DIR, 'cache');
+const SESSIONS_DIR = path.join(CACHE_DIR, 'sessions');
+const INSTANCES_DIR = path.join(EKKOS_DIR, 'instances');
+// Default instanceId when none provided (backward compatibility)
+exports.DEFAULT_INSTANCE_ID = 'default';
+/**
+ * Normalize instanceId - use 'default' if empty/undefined
+ */
+function normalizeInstanceId(instanceId) {
+    if (!instanceId || instanceId.trim() === '') {
+        return exports.DEFAULT_INSTANCE_ID;
+    }
+    return instanceId.trim();
+}
+/**
+ * Get the base ekkOS config directory
+ * ~/.ekkos on Unix, %USERPROFILE%\.ekkos on Windows
+ */
+function getConfigDir() {
+    return EKKOS_DIR;
+}
+/**
+ * Get the cache directory
+ * ~/.ekkos/cache
+ */
+function getCacheDir() {
+    return CACHE_DIR;
+}
+/**
+ * Get the sessions cache directory
+ * ~/.ekkos/cache/sessions
+ */
+function getSessionsDir() {
+    return SESSIONS_DIR;
+}
+/**
+ * Get the instance-scoped sessions directory
+ * ~/.ekkos/cache/sessions/{instanceId}
+ */
+function getInstanceSessionsDir(instanceId) {
+    const normalizedId = normalizeInstanceId(instanceId);
+    return path.join(SESSIONS_DIR, normalizedId);
+}
+/**
+ * Get the path to a session's turns JSONL file (instance-scoped)
+ * ~/.ekkos/cache/sessions/{instanceId}/{sessionId}.jsonl
+ */
+function getTurnsPath(instanceId, sessionId) {
+    const instanceDir = getInstanceSessionsDir(instanceId);
+    return path.join(instanceDir, `${sessionId}.jsonl`);
+}
+/**
+ * Get the path to a session's metadata file (instance-scoped)
+ * ~/.ekkos/cache/sessions/{instanceId}/{sessionId}.meta.json
+ */
+function getMetaPath(instanceId, sessionId) {
+    const instanceDir = getInstanceSessionsDir(instanceId);
+    return path.join(instanceDir, `${sessionId}.meta.json`);
+}
+/**
+ * Get the path to a session's stream log file (instance-scoped)
+ * ~/.ekkos/cache/sessions/{instanceId}/{sessionId}.stream.jsonl
+ */
+function getStreamLogPath(instanceId, sessionId) {
+    const instanceDir = getInstanceSessionsDir(instanceId);
+    return path.join(instanceDir, `${sessionId}.stream.jsonl`);
+}
+/**
+ * Get the path to a session's state file (instance-scoped)
+ * ~/.ekkos/cache/sessions/{instanceId}/{sessionId}.state.json
+ */
+function getStreamStatePath(instanceId, sessionId) {
+    const instanceDir = getInstanceSessionsDir(instanceId);
+    return path.join(instanceDir, `${sessionId}.state.json`);
+}
+/**
+ * Get the path to the session index file (instance-scoped)
+ * ~/.ekkos/cache/sessions/{instanceId}/index.json
+ */
+function getIndexPath(instanceId) {
+    const instanceDir = getInstanceSessionsDir(instanceId);
+    return path.join(instanceDir, 'index.json');
+}
+/**
+ * Get the instances directory
+ * ~/.ekkos/instances
+ */
+function getInstancesDir() {
+    return INSTANCES_DIR;
+}
+/**
+ * Get the path to an instance file
+ * ~/.ekkos/instances/{instanceId}.json
+ */
+function getInstanceFilePath(instanceId) {
+    return path.join(INSTANCES_DIR, `${instanceId}.json`);
+}
+/**
+ * Legacy path for backward compatibility (read-only fallback)
+ * ~/.ekkos/cache/sessions/{sessionId}.jsonl
+ */
+function getLegacyTurnsPath(sessionId) {
+    return path.join(SESSIONS_DIR, `${sessionId}.jsonl`);
+}
+/**
+ * Legacy metadata path for backward compatibility (read-only fallback)
+ * ~/.ekkos/cache/sessions/{sessionId}.meta.json
+ */
+function getLegacyMetaPath(sessionId) {
+    return path.join(SESSIONS_DIR, `${sessionId}.meta.json`);
+}
+/**
+ * Legacy stream log path for backward compatibility (read-only fallback)
+ * ~/.ekkos/cache/sessions/{sessionId}.stream.jsonl
+ */
+function getLegacyStreamLogPath(sessionId) {
+    return path.join(SESSIONS_DIR, `${sessionId}.stream.jsonl`);
+}
+/**
+ * Ensure a directory exists (mkdirp)
+ */
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * Ensure the instance sessions directory exists
+ */
+function ensureInstanceDir(instanceId) {
+    const instanceDir = getInstanceSessionsDir(instanceId);
+    ensureDir(instanceDir);
+    return instanceDir;
+}
+/**
+ * Ensure the base ekkOS directories exist
+ */
+function ensureBaseDirs() {
+    ensureDir(EKKOS_DIR);
+    ensureDir(CACHE_DIR);
+    ensureDir(SESSIONS_DIR);
+    ensureDir(INSTANCES_DIR);
+}
+/**
+ * List all instance directories under sessions cache
+ * Returns array of instanceIds
+ */
+function listInstanceIds() {
+    ensureDir(SESSIONS_DIR);
+    try {
+        const entries = fs.readdirSync(SESSIONS_DIR, { withFileTypes: true });
+        return entries
+            .filter(e => e.isDirectory())
+            .map(e => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check if a file exists at the instance-scoped path
+ * If not, check legacy path and return which one exists (if any)
+ */
+function findTurnsFile(instanceId, sessionId) {
+    // Try instance-scoped path first
+    const instancePath = getTurnsPath(instanceId, sessionId);
+    if (fs.existsSync(instancePath)) {
+        return { path: instancePath, isLegacy: false };
+    }
+    // Try legacy path as fallback (read-only)
+    const legacyPath = getLegacyTurnsPath(sessionId);
+    if (fs.existsSync(legacyPath)) {
+        return { path: legacyPath, isLegacy: true };
+    }
+    return null;
+}
+/**
+ * Check if a meta file exists at the instance-scoped path
+ * If not, check legacy path and return which one exists (if any)
+ */
+function findMetaFile(instanceId, sessionId) {
+    // Try instance-scoped path first
+    const instancePath = getMetaPath(instanceId, sessionId);
+    if (fs.existsSync(instancePath)) {
+        return { path: instancePath, isLegacy: false };
+    }
+    // Try legacy path as fallback (read-only)
+    const legacyPath = getLegacyMetaPath(sessionId);
+    if (fs.existsSync(legacyPath)) {
+        return { path: legacyPath, isLegacy: true };
+    }
+    return null;
+}
+/**
+ * Check if a stream log exists at the instance-scoped path
+ * If not, check legacy path and return which one exists (if any)
+ */
+function findStreamLogFile(instanceId, sessionId) {
+    // Try instance-scoped path first
+    const instancePath = getStreamLogPath(instanceId, sessionId);
+    if (fs.existsSync(instancePath)) {
+        return { path: instancePath, isLegacy: false };
+    }
+    // Try legacy path as fallback (read-only)
+    const legacyPath = getLegacyStreamLogPath(sessionId);
+    if (fs.existsSync(legacyPath)) {
+        return { path: legacyPath, isLegacy: true };
+    }
+    return null;
+}

package/dist/utils/session-words.json

@@ -1,119 +1,38 @@
 {
     "adjectives": [
-        "turbo", "mega", "hyper", "ultra", "super", "cosmic", "atomic", "quantum",
-        "stellar", "epic", "mighty", "zippy", "rapid", "swift", "brisk",
-        "hasty", "quick", "snappy", "speedy", "vivid",
-        "happy", "jolly", "merry", "cheerful", "bright", "sunny", "golden", "shiny",
-        "gleaming", "radiant", "glowing", "beaming", "sparkling", "dazzling", "brilliant",
-        "vibrant", "lively", "perky", "peppy", "bouncy",
-        "groovy", "jazzy", "funky", "zesty", "spicy", "crispy", "fluffy", "bubbly",
-        "fizzy", "sparkly", "chunky", "sassy", "quirky", "wacky", "zany",
-        "silly", "goofy", "witty", "clever", "punchy",
-        "slick", "sleek", "smooth", "polished", "refined", "elegant", "fancy", "dapper",
-        "stylish", "chic", "classy", "posh", "swanky", "ritzy", "plush",
-        "luxe", "deluxe", "premium", "elite", "prime",
-        "cyber", "digital", "binary", "pixel", "vector", "matrix", "neural", "quantum",
-        "crypto", "techno", "electric", "ionic", "plasma", "laser", "photon",
-        "nano", "micro", "giga", "mega", "tera",
-        "solar", "lunar", "cosmic", "stellar", "nebula", "aurora", "crystal", "prism",
-        "frost", "icy", "frozen", "arctic", "polar", "alpine", "misty",
-        "foggy", "hazy", "cloudy", "stormy", "windy",
-        "crimson", "scarlet", "ruby", "amber", "golden", "lime", "jade", "teal",
-        "azure", "cobalt", "violet", "purple", "magenta", "coral", "peach",
-        "bronze", "silver", "chrome", "onyx", "pearl",
-        "bold", "brave", "keen", "noble", "royal", "regal", "majestic", "grand",
-        "proud", "fierce", "wild", "free", "pure", "true", "real",
-        "honest", "loyal", "trusty", "sturdy", "solid",
-        "tiny", "mini", "micro", "petite", "small", "compact", "cozy", "snug",
-        "large", "huge", "giant", "massive", "grand", "vast", "broad",
-        "wide", "tall", "long", "big", "great",
-        "alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta",
-        "iota", "kappa", "lambda", "omega", "sigma", "tau", "phi",
-        "chi", "psi", "rho", "nu", "xi",
-        "metal", "steel", "iron", "copper", "bronze", "brass", "titanium", "platinum",
-        "diamond", "crystal", "glass", "marble", "granite", "stone", "wood",
-        "oak", "pine", "cedar", "bamboo", "silk", "velvet", "cotton", "wool",
-        "leather", "rubber", "plastic", "ceramic", "porcelain", "clay", "adobe",
-        "striped", "dotted", "spotted", "checked", "plaid", "solid", "gradient", "faded",
-        "mottled", "marbled", "speckled", "flecked", "dappled", "tinted", "shaded",
-        "frosted", "glazed", "painted", "carved", "etched"
+        "ace", "big", "blu", "coy", "dex",
+        "eco", "fab", "gem", "hex", "ice",
+        "jet", "key", "lux", "max", "neo",
+        "oak", "pop", "rad", "sky", "top",
+        "uno", "vex", "wax", "xen", "zen",
+        "hot", "red", "nox", "sol", "vim",
+        "ash", "dew", "fog", "glo", "ink",
+        "joy", "koi", "lit", "mox", "nix",
+        "orb", "pix", "qix", "rox", "sly",
+        "tek", "ulu", "vox", "wiz", "zap"
     ],
     "nouns": [
-        "penguin", "panda", "otter", "narwhal", "alpaca", "llama", "badger", "walrus",
-        "koala", "dolphin", "eagle", "falcon", "hawk", "raven", "owl",
-        "fox", "wolf", "bear", "tiger", "lion", "leopard", "panther",
-        "ferret", "gopher", "bobcat", "lynx", "cougar", "jaguar", "cheetah",
-        "elephant", "rhino", "hippo", "giraffe", "zebra", "bison", "moose",
-        "deer", "elk", "caribou", "antelope",
-        "waffle", "pickle", "noodle", "pretzel", "muffin", "taco", "nugget", "biscuit",
-        "donut", "bagel", "croissant", "scone", "danish", "turnover", "strudel",
-        "pizza", "burger", "hotdog", "sandwich", "wrap", "burrito", "quesadilla",
-        "nachos", "taco", "falafel", "gyro", "kebab", "samosa", "dumpling",
-        "ramen", "sushi", "tempura", "teriyaki", "miso", "udon", "soba",
-        "pasta", "ravioli", "gnocchi", "risotto",
-        "rocket", "comet", "nebula", "quasar", "meteor", "photon", "pulsar", "nova",
-        "supernova", "galaxy", "cosmos", "universe", "orbit", "asteroid", "planet",
-        "star", "moon", "sun", "eclipse", "solstice", "equinox", "aurora",
-        "constellation", "satellite", "probe", "shuttle", "capsule", "lander", "rover",
-        "beacon", "signal", "transmission", "relay", "array", "dish", "antenna",
-        "spectrum", "frequency", "wavelength", "radiation",
-        "ninja", "pirate", "wizard", "robot", "cyborg", "android", "knight", "warrior",
-        "samurai", "ronin", "monk", "sage", "oracle", "prophet", "seer",
-        "mage", "sorcerer", "warlock", "witch", "druid", "shaman", "mystic",
-        "hero", "champion", "legend", "titan", "colossus", "golem", "giant",
-        "sprite", "fairy", "pixie", "elf", "dwarf", "gnome", "goblin",
-        "dragon", "phoenix", "griffin", "sphinx",
-        "thunder", "lightning", "blizzard", "tornado", "hurricane", "cyclone", "typhoon", "monsoon",
-        "tempest", "storm", "gale", "breeze", "wind", "gust", "draft",
-        "rain", "drizzle", "shower", "downpour", "deluge", "flood", "torrent",
-        "snow", "sleet", "hail", "frost", "ice", "icicle", "glacier",
-        "fog", "mist", "haze", "cloud", "vapor", "steam", "smoke",
-        "dew", "droplet", "bubble", "sparkle",
-        "server", "laptop", "tablet", "phone", "screen", "keyboard", "mouse", "chip",
-        "processor", "memory", "drive", "disk", "cache", "buffer", "stack",
-        "queue", "thread", "process", "daemon", "kernel", "module", "plugin",
-        "widget", "gadget", "device", "sensor", "scanner", "printer", "router", "modem",
-        "guitar", "piano", "drums", "flute", "violin", "trumpet", "saxophone", "clarinet",
-        "trombone", "harp", "banjo", "ukulele", "cello", "viola", "bass",
-        "synthesizer", "organ", "accordion", "harmonica", "xylophone"
+        "ant", "bat", "cat", "dog", "elk",
+        "fox", "gnu", "hen", "imp", "jay",
+        "kit", "lex", "moo", "nub", "owl",
+        "pug", "ram", "sun", "tux", "urn",
+        "van", "web", "yak", "zed", "ape",
+        "bee", "cod", "doe", "eel", "fin",
+        "gup", "hog", "ion", "jab", "keg",
+        "log", "mud", "net", "oat", "pod",
+        "rye", "sap", "tar", "vat", "wok",
+        "box", "cub", "dip", "gem", "hub"
     ],
     "verbs": [
-        "runs", "walks", "jumps", "hops", "skips", "leaps", "bounds", "dashes",
-        "races", "sprints", "zooms", "zips", "flies", "soars", "glides",
-        "floats", "drifts", "swims", "dives", "surfs", "rides", "sails",
-        "climbs", "scales", "ascends", "descends", "slides", "slips", "rolls",
-        "spins", "twirls", "whirls", "rotates", "orbits", "circles", "loops",
-        "bounces", "springs", "vaults", "launches",
-        "builds", "creates", "makes", "crafts", "forges", "shapes", "molds", "forms",
-        "designs", "draws", "paints", "sketches", "writes", "codes", "types",
-        "clicks", "taps", "swipes", "scrolls", "drags", "drops", "picks",
-        "grabs", "holds", "carries", "lifts", "throws", "catches", "tosses",
-        "pushes", "pulls", "moves", "shifts", "slides", "turns", "flips",
-        "spins", "rotates", "twists", "bends",
-        "talks", "speaks", "says", "tells", "asks", "answers", "replies", "responds",
-        "shouts", "yells", "screams", "whispers", "murmurs", "mutters", "hums",
-        "sings", "chants", "calls", "cries", "laughs", "giggles", "chuckles",
-        "smiles", "grins", "beams", "glows", "shines", "sparkles", "glitters",
-        "blinks", "winks", "nods", "waves", "signals", "points", "gestures",
-        "shows", "reveals", "displays", "presents",
-        "thinks", "ponders", "wonders", "considers", "reflects", "meditates", "contemplates", "muses",
-        "dreams", "imagines", "envisions", "pictures", "visualizes", "sees", "views",
-        "watches", "observes", "notices", "spots", "finds", "discovers", "detects",
-        "learns", "studies", "reads", "explores", "investigates", "examines", "analyzes",
-        "solves", "figures", "calculates", "computes", "measures", "counts", "tallies",
-        "remembers", "recalls", "recollects", "recognizes",
-        "wins", "succeeds", "achieves", "accomplishes", "completes", "finishes", "conquers", "triumphs",
-        "celebrates", "cheers", "rejoices", "delights", "enjoys", "loves", "adores",
-        "helps", "aids", "assists", "supports", "guides", "leads", "directs",
-        "protects", "guards", "defends", "shields", "saves", "rescues", "recovers",
-        "heals", "fixes", "repairs", "restores", "renews", "refreshes", "revives",
-        "thrives", "grows", "blooms", "flourishes",
-        "compiles", "deploys", "merges", "commits", "pushes", "pulls", "clones", "forks",
-        "branches", "tags", "releases", "patches", "updates", "upgrades", "installs",
-        "uninstalls", "configures", "optimizes", "debugs", "tests", "validates", "verifies",
-        "authenticates", "authorizes", "encrypts", "decrypts", "compresses", "decompresses", "archives", "extracts",
-        "invents", "innovates", "improvises", "experiments", "discovers", "pioneers", "explores", "ventures",
-        "adapts", "evolves", "transforms", "revolutionizes", "reimagines", "redefines", "reinvents",
-        "generates", "synthesizes", "composes", "orchestrates", "choreographs"
+        "ask", "bet", "cut", "dig", "eat",
+        "fix", "get", "hit", "jab", "key",
+        "let", "mix", "nap", "opt", "pop",
+        "run", "set", "tap", "use", "vet",
+        "win", "zip", "zap", "add", "bid",
+        "dub", "end", "fly", "gig", "hum",
+        "jog", "lob", "map", "net", "orb",
+        "pay", "rip", "sip", "tag", "vow",
+        "wag", "yap", "bow", "cue", "dip",
+        "fan", "hop", "jam", "nod", "tug"
     ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekkos/cli",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
   "main": "dist/index.js",
   "bin": {