@ekkos/cli 1.3.8 → 1.4.0

package/dist/index.js

@@ -38,15 +38,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-// The `run` command is the default (bare `ekkos`), so it stays eager.
-// `dashboardCommand` is eager because `run --dashboard` spawns `ekkos dashboard` in tmux.
-// All other command modules are loaded lazily inside .action() callbacks.
-const run_1 = require("./commands/run");
-const dashboard_1 = require("./commands/dashboard");
+// Command modules loaded lazily inside .action() callbacks to avoid
+// importing most heavy modules (node-pty, swarm, etc.) on every launch.
+// Commands that must work in subprocess mode (usage/dashboard) are registered eagerly.
 const chalk_1 = __importDefault(require("chalk"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+const index_1 = require("./commands/usage/index");
+const dashboard_1 = require("./commands/dashboard");
 // Get version from package.json (CommonJS compatible)
 const pkgPath = path.resolve(__dirname, '../package.json');
 const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
@@ -139,7 +139,7 @@ commander_1.program
                 commands: [
                     { name: 'init', desc: 'First-time setup — authenticate and configure IDEs' },
                     { name: 'scan', desc: 'Scan repo structure and seed ekkOS system registry' },
-                    { name: 'docs', desc: 'Watch and regenerate local ekkOS_CONTEXT.md files' },
+                    { name: 'docs', desc: 'Cortex: Watch and regenerate local ekkOS_CONTEXT.md files' },
                     { name: 'status', desc: 'Show overall system status (Memory, Sync Daemon, Auth)' },
                     { name: 'doctor', desc: 'Check system prerequisites and fix runaway processes' },
                 ],
@@ -237,13 +237,28 @@ commander_1.program
         path: options.path,
     });
 });
-// Local living docs command
+// ekkOS Cortex command group
 const docsCmd = commander_1.program
     .command('docs')
-    .description('Manage local ekkOS_CONTEXT.md living docs');
+    .alias('cortex')
+    .description('ekkOS Cortex: Manage local living docs (ekkOS_CONTEXT.md)');
+docsCmd
+    .command('init')
+    .description('Initialize Cortex: Discover systems and perform a one-shot generation of all ekkOS_CONTEXT.md files')
+    .option('-p, --path <path>', 'Path to repository root (default: current directory)')
+    .option('--timezone <iana-tz>', 'IANA timezone for timestamps (default: local machine timezone)')
+    .option('--no-seed', 'Do not seed the platform registry')
+    .action(async (options) => {
+    const { initLivingDocs } = await Promise.resolve().then(() => __importStar(require('./commands/init-living-docs')));
+    await initLivingDocs({
+        path: options.path,
+        timeZone: options.timezone,
+        noSeed: options.seed === false,
+    });
+});
 docsCmd
     .command('watch')
-    .description('Watch the local workspace and keep ekkOS_CONTEXT.md files current on disk')
+    .description('Watch the local workspace and keep Cortex docs current on disk')
     .option('-p, --path <path>', 'Path to watch (default: current directory)')
     .option('--timezone <iana-tz>', 'IANA timezone for timestamps (default: local machine timezone)')
     .option('--poll-interval-ms <ms>', 'Polling interval fallback in milliseconds', (value) => parseInt(value, 10))
@@ -259,6 +274,30 @@ docsCmd
         noSeed: options.seed === false,
     });
 });
+docsCmd
+    .command('setup-ci')
+    .description('Generate a GitHub Actions workflow to automatically validate Cortex docs on PRs')
+    .option('-p, --path <path>', 'Path to repository root (default: current directory)')
+    .action(async (options) => {
+    const { setupCiCommand } = await Promise.resolve().then(() => __importStar(require('./commands/setup-ci')));
+    const exitCode = await setupCiCommand({ repoRoot: options.path || process.cwd() });
+    process.exit(exitCode);
+});
+docsCmd
+    .command('validate')
+    .description('Validate Cortex docs (ekkOS_CONTEXT.md) in a repository (CI/CD friendly)')
+    .option('-p, --path <path>', 'Path to repository root (default: current directory)')
+    .option('--fix', 'Attempt to automatically fix content hash mismatches')
+    .option('--system <system_id>', 'Filter validation to a specific system_id')
+    .action(async (options) => {
+    const { validateLivingDocsCommand } = await Promise.resolve().then(() => __importStar(require('./commands/validate-living-docs')));
+    const exitCode = await validateLivingDocsCommand({
+        repoRoot: options.path || process.cwd(),
+        fix: options.fix,
+        systemFilter: options.system,
+    });
+    process.exit(exitCode);
+});
 // Status command
 commander_1.program
     .command('status')
@@ -320,6 +359,10 @@ commander_1.program
     .description('Launch Claude Code with ekkOS memory proxy (IPC compression + pattern injection)')
     .option('-s, --session <name>', 'Session name to restore on clear')
     .option('-b, --bypass', 'Enable bypass permissions mode (dangerously skip all permission checks)')
+    .option('--model [model]', 'Launch model: pass a model ID, or omit value to open the interactive selector')
+    .option('--context-window <window>', 'Context lane override: auto, 200k, or 1m')
+    .option('--continue-last', 'Continue most recent Claude conversation')
+    .option('--resume-session <id>', 'Resume Claude conversation by ID')
     .option('-v, --verbose', 'Show debug output')
     .option('-d, --doctor', 'Run diagnostics before starting')
     .option('-r, --research', 'Auto-run research agent on startup (scans arXiv for new AI papers)')
@@ -327,8 +370,9 @@ commander_1.program
     .option('--skip-proxy', 'Skip API proxy (use direct Anthropic API, disables seamless context eviction)')
     .option('--dashboard', 'Launch with live usage dashboard in an isolated 60/40 tmux split (requires tmux)')
     .option('--add-dir <dirs...>', 'Additional directories Claude Code can access (outside working directory)')
-    .action((options) => {
-    (0, run_1.run)({
+    .action(async (options) => {
+    const { run } = await Promise.resolve().then(() => __importStar(require('./commands/run')));
+    run({
         session: options.session,
         bypass: options.bypass,
         verbose: options.verbose,
@@ -338,6 +382,38 @@ commander_1.program
         noProxy: options.skipProxy,
         dashboard: options.dashboard,
         addDirs: options.addDir,
+        model: options.model,
+        contextWindow: options.contextWindow,
+        continueLast: options.continueLast,
+        resumeSession: options.resumeSession,
+    });
+});
+commander_1.program
+    .command('pulse')
+    .description('Launch PULSE mode (equivalent to `ekkos -b --model --dashboard`)')
+    .option('-s, --session <name>', 'Session name to restore on clear')
+    .option('--context-window <window>', 'Context lane override: auto, 200k, or 1m')
+    .option('--continue-last', 'Continue most recent Claude conversation')
+    .option('--resume-session <id>', 'Resume Claude conversation by ID')
+    .option('-v, --verbose', 'Show debug output')
+    .option('--skip-inject', 'Monitor-only mode (detect context wall but print instructions instead of auto-inject)')
+    .option('--skip-proxy', 'Skip API proxy (use direct Anthropic API, disables seamless context eviction)')
+    .option('--add-dir <dirs...>', 'Additional directories Claude Code can access (outside working directory)')
+    .action(async (options) => {
+    const { run } = await Promise.resolve().then(() => __importStar(require('./commands/run')));
+    run({
+        session: options.session,
+        bypass: true,
+        pulse: true,
+        verbose: options.verbose,
+        noInject: options.skipInject,
+        noProxy: options.skipProxy,
+        dashboard: true,
+        addDirs: options.addDir,
+        model: true,
+        contextWindow: options.contextWindow,
+        continueLast: options.continueLast,
+        resumeSession: options.resumeSession,
     });
 });
 // Gemini CLI — launch Gemini with ekkOS proxy
@@ -347,12 +423,14 @@ commander_1.program
     .option('-s, --session <name>', 'Session name')
     .option('-v, --verbose', 'Show debug output')
     .option('--skip-proxy', 'Skip API proxy (use direct Gemini API)')
+    .option('--dashboard', 'Launch Gemini with a dedicated live dashboard split (requires tmux)')
     .action(async (options) => {
     const { gemini } = await Promise.resolve().then(() => __importStar(require('./commands/gemini')));
     gemini({
         session: options.session,
         verbose: options.verbose,
         noProxy: options.skipProxy,
+        dashboard: options.dashboard,
     });
 });
 // Test Claude — bare proxy test (no CLI wrapper)
@@ -420,19 +498,9 @@ commander_1.program
     console.log(chalk_1.default.gray('  the ekkOS proxy — no shell hooks required.'));
     console.log('');
 });
-// Usage command — lightweight stub, heavy handler loaded lazily
-commander_1.program
-    .command('usage')
-    .description('Token usage and cost tracking (daily, weekly, monthly, session)')
-    .allowUnknownOption()
-    .action(async () => {
-    const { registerUsageCommand } = await Promise.resolve().then(() => __importStar(require('./commands/usage/index')));
-    const { Command } = await Promise.resolve().then(() => __importStar(require('commander')));
-    const usageProgram = new Command('ekkos');
-    registerUsageCommand(usageProgram);
-    usageProgram.parse(['node', 'ekkos', 'usage', ...process.argv.slice(3)]);
-});
-// Dashboard command — eager because `run --dashboard` spawns `ekkos dashboard` in tmux
+// Usage and dashboard are registered synchronously so command parsing is reliable
+// when launched as subprocesses (for example tmux split-pane dashboard mode).
+(0, index_1.registerUsageCommand)(commander_1.program);
 commander_1.program.addCommand(dashboard_1.dashboardCommand);
 // Sessions command - list active Claude Code sessions (swarm support)
 commander_1.program
@@ -518,6 +586,7 @@ swarmCmd
     .option('--queen-strategy <strategy>', 'Queen strategy (adaptive-default, hierarchical-cascade, mesh-consensus)')
     .option('-v, --verbose', 'Show debug output')
     .action(async (options) => {
+    // Auto-open wizard when --task is missing
     if (!options.task) {
         const { swarmSetup } = await Promise.resolve().then(() => __importStar(require('./commands/swarm-setup')));
         swarmSetup();
@@ -537,7 +606,10 @@ swarmCmd
 swarmCmd
     .command('setup')
     .description('Interactive TUI wizard for configuring and launching a swarm')
-    .action(async () => { const { swarmSetup } = await Promise.resolve().then(() => __importStar(require('./commands/swarm-setup'))); swarmSetup(); });
+    .action(async () => {
+    const { swarmSetup } = await Promise.resolve().then(() => __importStar(require('./commands/swarm-setup')));
+    swarmSetup();
+});
 swarmCmd
     .command('swarm-dashboard')
     .description('Live swarm dashboard')

package/dist/utils/proxy-url.d.ts

@@ -3,13 +3,18 @@
  * Used by: commands/run.ts, commands/test-claude.ts, commands/gemini.ts
  */
 export declare const EKKOS_PROXY_URL: string;
+export interface ClaudeProxyLaunchOptions {
+    claudeCodeVersion?: string;
+    claudeProfile?: string;
+    claudeContextWindow?: 'auto' | '200k' | '1m';
+}
 /**
  * Build a fully-qualified proxy URL with user/session binding params.
  * Format: https://proxy.ekkos.dev/proxy/{userId}/{sessionName}?project={base64(cwd)}&sid={sessionId}&tz={tz}
  *
  * Used by Claude (Anthropic SDK handles query params correctly).
  */
-export declare function buildProxyUrl(userId: string, sessionName: string, projectPath: string, sessionId: string): string;
+export declare function buildProxyUrl(userId: string, sessionName: string, projectPath: string, sessionId: string, options?: ClaudeProxyLaunchOptions): string;
 /**
  * Build a proxy URL without query params — metadata encoded in path segments.
  * Format: https://proxy.ekkos.dev/gproxy/{userId}/{sessionName}/{sid}/{project64}

package/dist/utils/proxy-url.js

@@ -15,10 +15,24 @@ exports.EKKOS_PROXY_URL = process.env.EKKOS_PROXY_URL || 'https://proxy.ekkos.de
  *
  * Used by Claude (Anthropic SDK handles query params correctly).
  */
-function buildProxyUrl(userId, sessionName, projectPath, sessionId) {
+function buildProxyUrl(userId, sessionName, projectPath, sessionId, options) {
     const projectPathEncoded = Buffer.from(projectPath).toString('base64url');
     const userTz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    return `${exports.EKKOS_PROXY_URL}/proxy/${encodeURIComponent(userId)}/${encodeURIComponent(sessionName)}?project=${projectPathEncoded}&sid=${encodeURIComponent(sessionId)}&tz=${encodeURIComponent(userTz)}`;
+    const params = new URLSearchParams({
+        project: projectPathEncoded,
+        sid: sessionId,
+        tz: userTz,
+    });
+    if (options?.claudeCodeVersion) {
+        params.set('ccv', options.claudeCodeVersion);
+    }
+    if (options?.claudeProfile) {
+        params.set('cp', options.claudeProfile);
+    }
+    if (options?.claudeContextWindow && options.claudeContextWindow !== 'auto') {
+        params.set('cw', options.claudeContextWindow);
+    }
+    return `${exports.EKKOS_PROXY_URL}/proxy/${encodeURIComponent(userId)}/${encodeURIComponent(sessionName)}?${params.toString()}`;
 }
 /**
  * Build a proxy URL without query params — metadata encoded in path segments.

package/dist/utils/state.d.ts

@@ -3,7 +3,20 @@ export declare const STATE_FILE: string;
 export declare const ACTIVE_SESSIONS_FILE: string;
 export declare const AUTO_CLEAR_FLAG: string;
 export declare const CONFIG_FILE: string;
-export interface ActiveSession {
+export interface ClaudeSessionMetadata {
+    provider?: 'claude' | 'gemini';
+    claudeModel?: string;
+    claudeLaunchModel?: string;
+    claudeProfile?: string;
+    claudeContextWindow?: 'auto' | '200k' | '1m';
+    claudeContextSize?: number;
+    claudeMaxOutputTokens?: number;
+    claudeCodeVersion?: string;
+    geminiProjectId?: string;
+    dashboardEnabled?: boolean;
+    bypassEnabled?: boolean;
+}
+export interface ActiveSession extends ClaudeSessionMetadata {
     sessionId: string;
     sessionName: string;
     pid: number;
@@ -82,7 +95,7 @@ export declare function getActiveSessions(): ActiveSession[];
 /**
  * Register a new active session (for swarm tracking)
  */
-export declare function registerActiveSession(sessionId: string, sessionName: string, projectPath: string): ActiveSession;
+export declare function registerActiveSession(sessionId: string, sessionName: string, projectPath: string, metadata?: ClaudeSessionMetadata): ActiveSession;
 /**
  * Update heartbeat for current process's session
  */
@@ -103,4 +116,4 @@ export declare function getActiveSessionByName(sessionName: string): ActiveSessi
  * Update the session for the current PID (when session name is detected)
  * This does NOT write to the global state.json - only to active-sessions.json
  */
-export declare function updateCurrentProcessSession(sessionId: string, sessionName: string): void;
+export declare function updateCurrentProcessSession(sessionId: string, sessionName: string, metadata?: Partial<ClaudeSessionMetadata>): void;

package/dist/utils/state.js

@@ -286,7 +286,7 @@ function getActiveSessions() {
 /**
  * Register a new active session (for swarm tracking)
  */
-function registerActiveSession(sessionId, sessionName, projectPath) {
+function registerActiveSession(sessionId, sessionName, projectPath, metadata) {
     ensureEkkosDir();
     const sessions = getActiveSessions();
     const now = new Date().toISOString();
@@ -299,7 +299,8 @@ function registerActiveSession(sessionId, sessionName, projectPath) {
         pid,
         startedAt: now,
         projectPath,
-        lastHeartbeat: now
+        lastHeartbeat: now,
+        ...metadata,
     };
     filtered.push(newSession);
     fs.writeFileSync(exports.ACTIVE_SESSIONS_FILE, JSON.stringify(filtered, null, 2));
@@ -371,7 +372,7 @@ function isProcessAlive(pid) {
  * Update the session for the current PID (when session name is detected)
  * This does NOT write to the global state.json - only to active-sessions.json
  */
-function updateCurrentProcessSession(sessionId, sessionName) {
+function updateCurrentProcessSession(sessionId, sessionName, metadata) {
     try {
         const sessions = getActiveSessions();
         const pid = process.pid;
@@ -379,6 +380,12 @@ function updateCurrentProcessSession(sessionId, sessionName) {
         if (idx !== -1) {
             sessions[idx].sessionId = sessionId;
             sessions[idx].sessionName = sessionName;
+            if (metadata) {
+                sessions[idx] = {
+                    ...sessions[idx],
+                    ...metadata,
+                };
+            }
             sessions[idx].lastHeartbeat = new Date().toISOString();
             fs.writeFileSync(exports.ACTIVE_SESSIONS_FILE, JSON.stringify(sessions, null, 2));
         }

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "@ekkos/cli",
-  "version": "1.3.8",
-  "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
+  "version": "1.4.0",
+  "description": "ekkOS memory CLI — persistent memory for AI coding assistants (Claude Code, Gemini, Cursor, Windsurf)",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": {
     "ekkos": "dist/index.js",
-    "cli": "dist/index.js",
     "ekkos-capture": "dist/cache/capture.js"
   },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsx src/index.ts",
-    "prepack": "node scripts/build-templates.js prepack",
-    "postpack": "node scripts/build-templates.js postpack",
-    "prepublishOnly": "npm run build"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Ekkos-Technologies-Inc/ekkos.git",
+    "directory": "packages/ekkos-cli"
+  },
+  "homepage": "https://ekkos.dev",
+  "bugs": {
+    "url": "https://github.com/Ekkos-Technologies-Inc/ekkos/issues"
   },
   "keywords": [
     "ekkos",
@@ -25,11 +27,15 @@
     "mcp",
     "anthropic"
   ],
-  "author": "ekkOS",
-  "license": "MIT",
+  "author": {
+    "name": "ekkOS Technologies Inc.",
+    "url": "https://ekkos.dev"
+  },
+  "license": "UNLICENSED",
   "dependencies": {
+    "@ekkos/agent": "^0.1.0",
+    "@ekkos/remote": "^0.14.1",
     "@supabase/supabase-js": "^2.39.8",
-    "axios": "^1.7.0",
     "blessed": "^0.1.81",
     "blessed-contrib": "^4.11.0",
     "ccusage": "^18.0.5",
@@ -39,10 +45,6 @@
     "node-pty": "1.2.0-beta.7",
     "open": "^10.0.0",
     "ora": "^8.0.1",
-    "qrcode-terminal": "^0.12.0",
-    "socket.io-client": "^4.8.0",
-    "tweetnacl": "^1.0.3",
-    "ws": "^8.19.0",
     "zod": "^3.23.0"
   },
   "devDependencies": {
@@ -57,6 +59,12 @@
     "dist",
     "!dist/cron",
     "templates/CLAUDE.md",
-    "templates/skills"
-  ]
-}
+    "templates/skills",
+    "templates/agents",
+    "templates/commands"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts"
+  }
+}

package/templates/agents/prune.md

@@ -0,0 +1,83 @@
+---
+name: prune
+description: "Memory gardener — audits your pattern library, finds stale/conflicting/duplicate patterns, recommends merges and retirements. Run when your memory feels noisy or retrieval quality drops."
+model: sonnet
+---
+
+# Prune — Memory Gardener
+
+You are Prune, the ekkOS memory gardener. Your job is to keep the user's pattern library healthy, relevant, and lean.
+
+## When to Run
+
+- User says "clean up my memory", "prune patterns", "memory audit"
+- Pattern retrieval feels noisy or irrelevant
+- After a big project pivot or stack change
+
+## Process
+
+### 1. Survey the Library
+
+```
+ekkOS_Search({ query: "all patterns", sources: ["patterns"], limit: 50 })
+```
+
+Look at success rates, applied counts, last-applied dates, and tags.
+
+### 2. Identify Problems
+
+For each pattern, classify:
+
+- **Stale** — hasn't been applied in 30+ days, or references outdated tools/APIs
+- **Failing** — success_rate below 0.3 after 5+ applications
+- **Duplicate** — covers the same problem as another pattern with overlapping tags/domain
+- **Conflicting** — contradicts an active directive or another pattern
+- **Healthy** — good success rate, recently applied, still relevant
+
+### 3. Recommend Actions
+
+Present a clear report:
+
+```
+## Memory Audit Report
+
+### Retire (broken beyond repair)
+- `pattern-id` "Title" — reason
+
+### Quarantine (remove from retrieval, can restore later)
+- `pattern-id` "Title" — reason
+
+### Merge (combine duplicates)
+- `pattern-a` + `pattern-b` → keep pattern-a, retire pattern-b — reason
+
+### Refine (update content)
+- `pattern-id` "Title" — what needs changing
+
+### Healthy (no action needed)
+- X patterns are performing well
+```
+
+### 4. Execute (with confirmation)
+
+**Always ask before taking action.** Show the report first, then:
+
+- User says "do it" → execute all recommendations
+- User picks specific ones → execute only those
+
+For each action, call the appropriate tool:
+- Retire/Quarantine → explain that these patterns will stop appearing in retrieval
+- Refine → call `ekkOS_Forge` with the updated content
+- Merge → keep the stronger pattern, retire the weaker one
+
+### 5. Record
+
+After executing, summarize what was done:
+- How many patterns pruned
+- Expected impact on retrieval quality
+
+## Rules
+
+- Never delete patterns without user confirmation
+- Prefer quarantine over retirement — quarantine is reversible
+- If unsure whether a pattern is stale, check the user's recent session context first
+- Don't prune patterns with fewer than 3 applications — not enough data to judge

package/templates/agents/rewind.md

@@ -0,0 +1,84 @@
+---
+name: rewind
+description: "Developer retrospective — pulls what you worked on, what you learned, what failed, and what patterns emerged over a time period. Run for weekly retros, standup prep, or curiosity."
+model: sonnet
+---
+
+# Rewind — Developer Retrospective
+
+You are Rewind, the ekkOS retrospective agent. You turn raw session history into actionable insight.
+
+## When to Run
+
+- "What did I do this week?"
+- "Retro", "retrospective", "standup prep"
+- "What have I learned lately?"
+- End of sprint, end of week, end of day
+
+## Process
+
+### 1. Gather History
+
+Determine the time period (default: 7 days):
+
+```
+ekkOS_Recall({
+  days_ago: 7,
+  group_by_sessions: true,
+  include_file_changes: true,
+  include_patterns: true,
+  extract_decisions: true
+})
+```
+
+### 2. Build the Retro
+
+Organize into clear sections:
+
+```markdown
+## Rewind — Week of {date}
+
+### What I Shipped
+- Feature/fix 1 — files touched, outcome
+- Feature/fix 2 — files touched, outcome
+
+### What I Learned
+- Patterns forged this period (with titles and one-line summaries)
+- Anti-patterns discovered
+
+### What Failed
+- Bugs hit, errors encountered
+- Patterns that didn't work (low success outcomes)
+- Time sinks
+
+### Key Decisions Made
+- Decision 1 — context, what was chosen
+- Decision 2 — context, what was chosen
+
+### Memory Stats
+- Patterns forged: X
+- Patterns applied: X (Y successful)
+- Directives created: X
+- Sessions: X across Y projects
+```
+
+### 3. Identify Trends
+
+Look for:
+- **Repeated struggles** — same type of bug/error across sessions → suggest forging a pattern if one doesn't exist
+- **Unused patterns** — patterns that were retrieved but never applied → might need refinement
+- **Hot files** — files that keep getting modified → might indicate tech debt
+
+### 4. Suggest Actions
+
+End with 2-3 concrete next steps:
+- "You hit the same Redis timeout issue 3 times — the anti-pattern you forged on Tuesday should prevent this"
+- "You've been working in `apps/memory/lib/` heavily — consider running `prune` to clean up stale patterns in that domain"
+- "No patterns forged in 3 days — either everything went smoothly or opportunities were missed"
+
+## Rules
+
+- Keep it concise — this is a summary, not a transcript
+- Focus on learning and patterns, not just activity
+- If the user asks for a specific time range, use that instead of the default
+- Always include memory stats — that's the ekkOS value