@ekkos/cli 0.2.18 → 1.0.0

package/dist/utils/verify-remote-terminal.js

@@ -0,0 +1,415 @@
+"use strict";
+/**
+ * Remote Terminal Verification Script
+ *
+ * Systematically verifies that all remote terminal components are properly configured
+ * and working correctly. Run this after setup-remote to validate the installation.
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyRemoteTerminal = verifyRemoteTerminal;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const EKKOS_DIR = path.join(os.homedir(), '.ekkos');
+const results = [];
+/**
+ * Test 1: Device configuration file exists
+ */
+function testDeviceConfig() {
+    const devicePath = path.join(EKKOS_DIR, 'device.json');
+    if (fs.existsSync(devicePath)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(devicePath, 'utf-8'));
+            if (data.deviceId && data.deviceToken && data.deviceName) {
+                results.push({
+                    name: 'Device Configuration',
+                    status: 'pass',
+                    message: 'Device config found and valid',
+                    details: `Device: ${data.deviceName} (${data.deviceId.slice(0, 8)}...)`,
+                });
+            }
+            else {
+                results.push({
+                    name: 'Device Configuration',
+                    status: 'fail',
+                    message: 'Device config exists but is incomplete',
+                });
+            }
+        }
+        catch (err) {
+            results.push({
+                name: 'Device Configuration',
+                status: 'fail',
+                message: 'Device config is invalid JSON',
+            });
+        }
+    }
+    else {
+        results.push({
+            name: 'Device Configuration',
+            status: 'fail',
+            message: 'Device not configured - run ekkos setup-remote',
+        });
+    }
+}
+/**
+ * Test 2: Service is installed
+ */
+function testServiceInstalled() {
+    const platform = os.platform();
+    try {
+        if (platform === 'darwin') {
+            // macOS: check launchctl
+            const output = (0, child_process_1.execSync)('launchctl list | grep dev.ekkos.agent || true', {
+                encoding: 'utf-8',
+            });
+            if (output.includes('dev.ekkos.agent')) {
+                results.push({
+                    name: 'Service Installation',
+                    status: 'pass',
+                    message: 'Service is installed on macOS',
+                });
+            }
+            else {
+                results.push({
+                    name: 'Service Installation',
+                    status: 'fail',
+                    message: 'Service not found - run ekkos agent start',
+                });
+            }
+        }
+        else if (platform === 'win32') {
+            // Windows: check scheduled task
+            const output = (0, child_process_1.execSync)('schtasks /query /tn "ekkOS Agent" 2>nul || echo NOT_FOUND', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            if (!output.includes('NOT_FOUND')) {
+                results.push({
+                    name: 'Service Installation',
+                    status: 'pass',
+                    message: 'Service is installed on Windows',
+                });
+            }
+            else {
+                results.push({
+                    name: 'Service Installation',
+                    status: 'fail',
+                    message: 'Service not found - run ekkos agent start',
+                });
+            }
+        }
+        else if (platform === 'linux') {
+            // Linux: check systemd
+            const output = (0, child_process_1.execSync)('systemctl --user is-active ekkos-agent 2>/dev/null || echo INACTIVE', {
+                encoding: 'utf-8',
+            });
+            if (output.includes('active')) {
+                results.push({
+                    name: 'Service Installation',
+                    status: 'pass',
+                    message: 'Service is installed on Linux',
+                });
+            }
+            else {
+                results.push({
+                    name: 'Service Installation',
+                    status: 'fail',
+                    message: 'Service not active - run ekkos agent start',
+                });
+            }
+        }
+    }
+    catch (err) {
+        results.push({
+            name: 'Service Installation',
+            status: 'fail',
+            message: 'Failed to check service status',
+            details: String(err).slice(0, 100),
+        });
+    }
+}
+/**
+ * Test 3: Service is running
+ */
+function testServiceRunning() {
+    const pidPath = path.join(EKKOS_DIR, 'agent.pid');
+    if (!fs.existsSync(pidPath)) {
+        results.push({
+            name: 'Service Running',
+            status: 'fail',
+            message: 'No PID file - service may not have started',
+        });
+        return;
+    }
+    try {
+        const pid = parseInt(fs.readFileSync(pidPath, 'utf-8').trim());
+        (0, child_process_1.execSync)(`kill -0 ${pid} 2>/dev/null`);
+        results.push({
+            name: 'Service Running',
+            status: 'pass',
+            message: `Process running (PID ${pid})`,
+        });
+    }
+    catch {
+        results.push({
+            name: 'Service Running',
+            status: 'fail',
+            message: 'PID file exists but process is not running - restart with ekkos agent restart',
+        });
+    }
+}
+/**
+ * Test 4: Logs are being written
+ */
+function testLogsWriting() {
+    const logPath = path.join(EKKOS_DIR, 'agent.log');
+    if (!fs.existsSync(logPath)) {
+        results.push({
+            name: 'Log Output',
+            status: 'warn',
+            message: 'No logs yet - service may not have started or run long enough',
+        });
+        return;
+    }
+    try {
+        const stats = fs.statSync(logPath);
+        const lastModified = Date.now() - stats.mtime.getTime();
+        const fiveMinutes = 5 * 60 * 1000;
+        if (lastModified < fiveMinutes) {
+            results.push({
+                name: 'Log Output',
+                status: 'pass',
+                message: `Logs updating (last write ${Math.round(lastModified / 1000)}s ago)`,
+            });
+        }
+        else {
+            results.push({
+                name: 'Log Output',
+                status: 'warn',
+                message: `No logs written for ${Math.round(lastModified / 1000 / 60)}m - check for errors`,
+            });
+        }
+    }
+    catch (err) {
+        results.push({
+            name: 'Log Output',
+            status: 'fail',
+            message: 'Failed to read log file',
+        });
+    }
+}
+/**
+ * Test 5: Network connectivity to relay
+ */
+async function testNetworkConnectivity() {
+    try {
+        const RELAY_URL = 'wss://ekkos-relay-production.up.railway.app';
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        const response = await fetch(`${RELAY_URL}/api/v1/health`, {
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (response.ok) {
+            results.push({
+                name: 'Network Connectivity',
+                status: 'pass',
+                message: 'Relay server is reachable',
+            });
+        }
+        else {
+            results.push({
+                name: 'Network Connectivity',
+                status: 'warn',
+                message: `Relay server returned ${response.status}`,
+            });
+        }
+    }
+    catch (err) {
+        if (err.name === 'AbortError') {
+            results.push({
+                name: 'Network Connectivity',
+                status: 'fail',
+                message: 'Timeout connecting to relay (>5s) - check internet connection',
+            });
+        }
+        else {
+            results.push({
+                name: 'Network Connectivity',
+                status: 'fail',
+                message: `Cannot reach relay server: ${err.message}`,
+            });
+        }
+    }
+}
+/**
+ * Test 6: WebSocket connection from daemon
+ */
+function testDaemonConnection() {
+    const logPath = path.join(EKKOS_DIR, 'agent.log');
+    if (!fs.existsSync(logPath)) {
+        results.push({
+            name: 'Daemon WebSocket',
+            status: 'warn',
+            message: 'Cannot check - no logs yet',
+        });
+        return;
+    }
+    try {
+        const content = fs.readFileSync(logPath, 'utf-8');
+        const lines = content.split('\n');
+        const lastLines = lines.slice(-50);
+        const hasConnected = lastLines.some(l => l.includes('Connected to relay server'));
+        const hasRegistered = lastLines.some(l => l.includes('Registered with relay'));
+        const hasError = lastLines.some(l => l.includes('WebSocket error'));
+        const hasDisconnected = lastLines.some(l => l.includes('Disconnected'));
+        if (hasConnected && hasRegistered && !hasError) {
+            results.push({
+                name: 'Daemon WebSocket',
+                status: 'pass',
+                message: 'Daemon connected and registered with relay',
+            });
+        }
+        else if (hasDisconnected && !hasConnected) {
+            results.push({
+                name: 'Daemon WebSocket',
+                status: 'warn',
+                message: 'Daemon disconnected - reconnecting, check again in 30s',
+            });
+        }
+        else if (hasError) {
+            results.push({
+                name: 'Daemon WebSocket',
+                status: 'fail',
+                message: 'Daemon has WebSocket errors - check network and firewall',
+                details: lastLines
+                    .filter(l => l.includes('error'))
+                    .slice(-1)[0],
+            });
+        }
+        else {
+            results.push({
+                name: 'Daemon WebSocket',
+                status: 'warn',
+                message: 'Unknown connection state - run ekkos agent logs -f to monitor',
+            });
+        }
+    }
+    catch (err) {
+        results.push({
+            name: 'Daemon WebSocket',
+            status: 'fail',
+            message: 'Failed to read logs',
+        });
+    }
+}
+/**
+ * Print verification results
+ */
+function printResults() {
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('  Remote Terminal Verification'));
+    console.log('');
+    let passed = 0;
+    let warned = 0;
+    let failed = 0;
+    for (const result of results) {
+        let icon = '';
+        let color = chalk_1.default.gray;
+        if (result.status === 'pass') {
+            icon = chalk_1.default.green('✓');
+            color = chalk_1.default.green;
+            passed++;
+        }
+        else if (result.status === 'warn') {
+            icon = chalk_1.default.yellow('⚠');
+            color = chalk_1.default.yellow;
+            warned++;
+        }
+        else {
+            icon = chalk_1.default.red('✗');
+            color = chalk_1.default.red;
+            failed++;
+        }
+        console.log(`  ${icon} ${color(result.name)}`);
+        console.log(`    ${result.message}`);
+        if (result.details) {
+            console.log(`    ${chalk_1.default.gray(result.details.slice(0, 80))}`);
+        }
+    }
+    console.log('');
+    console.log(chalk_1.default.gray(`  Results: ${chalk_1.default.green(`${passed} pass`)}, ${chalk_1.default.yellow(`${warned} warn`)}, ${chalk_1.default.red(`${failed} fail`)}`));
+    console.log('');
+    // Overall status
+    if (failed === 0) {
+        if (warned === 0) {
+            console.log(chalk_1.default.green('  ✓ All checks passed!'));
+        }
+        else {
+            console.log(chalk_1.default.yellow('  ⚠ Most checks passed, but review warnings above.'));
+        }
+    }
+    else {
+        console.log(chalk_1.default.red('  ✗ Some checks failed. See above for fixes.'));
+    }
+    console.log('');
+    // Next steps
+    if (failed > 0) {
+        console.log(chalk_1.default.cyan('  Next steps:'));
+        console.log('    1. Review failed checks above');
+        console.log('    2. Run suggested commands');
+        console.log('    3. Wait 30s and run this verification again');
+        console.log('');
+    }
+}
+/**
+ * Run all verification tests
+ */
+async function verifyRemoteTerminal() {
+    testDeviceConfig();
+    testServiceInstalled();
+    testServiceRunning();
+    testLogsWriting();
+    await testNetworkConnectivity();
+    testDaemonConnection();
+    printResults();
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@ekkos/cli",
-  "version": "0.2.18",
+  "version": "1.0.0",
   "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
   "main": "dist/index.js",
   "bin": {
     "ekkos": "dist/index.js",
     "cli": "dist/index.js",
-    "ekkos-capture": "dist/cache/capture.js"
+    "ekkos-capture": "dist/cache/capture.js",
+    "ekkos-promote": "dist/cron/promoter.js"
   },
   "scripts": {
     "build": "tsc",
@@ -28,6 +29,11 @@
   "author": "ekkOS",
   "license": "MIT",
   "dependencies": {
+    "@ekkos/prometheus": "*",
+    "@supabase/supabase-js": "^2.39.8",
+    "blessed": "^0.1.81",
+    "blessed-contrib": "^4.11.0",
+    "ccusage": "^18.0.5",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "inquirer": "^9.2.23",
@@ -37,6 +43,7 @@
     "ws": "^8.19.0"
   },
   "devDependencies": {
+    "@types/blessed": "^0.1.27",
     "@types/node": "^20.11.0",
     "typescript": "^5.3.3"
   },

package/templates/CLAUDE.md

@@ -53,6 +53,28 @@ After `/clear`, when you see restored turns in `<system-reminder>` (pattern: `**
 ```
 This is the ONLY way users see that restoration worked. Hook output is invisible to them.
 
+### RULE 6: AUTO-RESTORE AFTER COMPACTION (CONTEXT GUARDIAN)
+When you see `<ekkos-context-preserved>` in the conversation (appears after auto-compaction):
+1. **IMMEDIATELY** call `ekkOS_RestoreContext` with the `restoration_token` from the tag
+2. This restores your working memory that was preserved before compaction
+3. Start your response with:
+```
+✓ **Context restored** - ekkOS preserved X turns before compaction
+```
+
+**This is how seamless context continuity works:**
+- PreCompact hook fires → ekkOS_PreserveContext saves your state
+- Claude Code compacts → Summary includes the preservation tag
+- You see the tag → Call ekkOS_RestoreContext → Full context restored
+- User experiences zero knowledge loss despite compaction
+
+**Example restoration call:**
+```
+ekkOS_RestoreContext({
+  restoration_token: "<token from tag>"
+})
+```
+
 ---
 
 ## SKILL TRIGGERS (MANDATORY)
@@ -79,8 +101,7 @@ Call skills using `Skill(skill: "name")` when you detect these triggers:
 | Trigger Keywords | Agent | When to Use |
 |------------------|-------|-------------|
 | extension, vsix, publish, marketplace, ekkos-connect | `extension-manager` | Version bumps, VSIX builds, publishing |
-| vercel, deploy to vercel, platform.ekkos.dev, apps/web | `devops` | Vercel deployments (link + archive mode) |
-| deploy, railway, workers, pm2, restart, logs, queue | `railway-manager` | Railway deployments, service management |
+| vercel, deploy, apps/*, ekkos.dev, api.ekkos.dev | `devops` | Vercel deployments — ALL apps/ deploy to Vercel |
 | commit, push, branch, merge, git, pull request, rebase | `git-companion` | All git operations |
 | error, bug, broken, not working, failing, crash | `debug-detective` | Systematic debugging |
 | review, PR, check this code, code quality | `code-reviewer` | Code reviews |
@@ -89,6 +110,25 @@ Call skills using `Skill(skill: "name")` when you detect these triggers:
 | backend, API, database, Supabase, RLS | `backend` | API and database work |
 | test, QA, quality, coverage | `qa` | Testing and quality assurance |
 | plan, architect, design, implement feature | `tech-lead` | Complex planning and coordination |
+| research, papers, arXiv, cutting edge, latest AI | `research-scout` | Monitor AI research, update roadmap |
+
+**Vercel Project Mapping** (apps/ folder → Vercel project → URL):
+
+| apps/ folder | Vercel project | Production URL |
+|-------------|----------------|----------------|
+| `apps/web` | **platform** | platform.ekkos.dev |
+| `apps/memory` | memory | api.ekkos.dev |
+| `apps/proxy` | proxy | proxy.ekkos.dev |
+| `apps/docs` | docs | docs.ekkos.dev |
+| `apps/marketing` | marketing | ekkos.dev |
+| `apps/ekkosca` | ekkosca | ekkos.ca |
+| `apps/blog` | blog | blog.ekkos.dev |
+| `apps/support` | support | support.ekkos.dev |
+| `apps/labs` | labs | ekkoslabs.com |
+| `apps/admin` | admin | admin.ekkos.ca |
+| `apps/sdk` | sdk | sdk-ekkos.vercel.app |
+
+**NOTE:** `apps/web` → Vercel project name is `platform`, NOT `web`.
 
 **How it works:**
 1. Detect trigger keywords in user request
@@ -109,39 +149,55 @@ You: Task(subagent_type="extension-manager", prompt="Bump version...")
 
 ---
 
-## MCP Tools (31 Total)
+## MCP Tools (68 Total)
 
-### Core Memory Tools
+### Core Memory Tools (7)
 | Tool | Description |
 |------|-------------|
 | `ekkOS_Search` | 🔴 REQUIRED: Search all 11 layers before answering |
-| `ekkOS_Context` | Get relevant context for a task |
+| `ekkOS_ExpandPattern` | Get full details of a pattern from compact search results |
 | `ekkOS_Capture` | Capture memory events |
 | `ekkOS_Forge` | 🔴 REQUIRED: Create pattern from solution |
-| `ekkOS_Directive` | 🔴 REQUIRED: Create MUST/NEVER/PREFER/AVOID rules |
+| `ekkOS_Track` | Track when pattern is applied |
 | `ekkOS_Outcome` | Track if pattern worked or failed |
-| `ekkOS_Detect` | 🔴 REQUIRED: Auto-detect which patterns were used |
-| `ekkOS_Summary` | 🔴 REQUIRED: Get summary of MCP activity |
-| `ekkOS_Conflict` | 🔴 REQUIRED: Check for conflicts before destructive actions |
-| `ekkOS_Recall` | Recall past conversations by time |
-| `ekkOS_Codebase` | Search project code embeddings |
 | `ekkOS_Stats` | Get statistics for all layers |
-| `ekkOS_Track` | Track when pattern is applied |
-| `ekkOS_Reflect` | Analyze response for improvement opportunities |
 
-### Schema Awareness Tools
+### Context & Retrieval Tools (5)
 | Tool | Description |
 |------|-------------|
-| `ekkOS_IndexSchema` | Index database schemas (Supabase, Prisma, TypeScript) |
-| `ekkOS_GetSchema` | Get schema for a specific table/type |
+| `ekkOS_Context` | Get relevant context for a task |
+| `ekkOS_Codebase` | Search project code embeddings |
+| `ekkOS_Recall` | Recall past conversations by time |
+| `ekkOS_PreserveContext` | 🔴 REQUIRED: Preserve working memory before compaction |
+| `ekkOS_RestoreContext` | 🔴 REQUIRED: Restore context after compaction (RULE 6) |
 
-### Portability Tools
+### Utility Tools (8)
 | Tool | Description |
 |------|-------------|
+| `ekkOS_Summary` | 🔴 REQUIRED: Get summary of MCP activity |
+| `ekkOS_Conflict` | 🔴 REQUIRED: Check for conflicts before destructive actions |
+| `ekkOS_Reflect` | Analyze response for improvement opportunities |
+| `ekkOS_Detect` | 🔴 REQUIRED: Auto-detect which patterns were used |
 | `ekkOS_Export` | Export your patterns, directives, plans as portable JSON backup |
 | `ekkOS_Import` | Import memory from backup (auto-deduplication) |
+| `ekkOS_Why` | Explain why a pattern or decision was made |
+| `ekkOS_Health` | System health check for ekkOS infrastructure |
+
+### Directive Tools (4)
+| Tool | Description |
+|------|-------------|
+| `ekkOS_Directive` | 🔴 REQUIRED: Create MUST/NEVER/PREFER/AVOID rules |
+| `ekkOS_UpdateDirective` | Update existing directive |
+| `ekkOS_DeleteDirective` | Remove a directive |
+| `ekkOS_UniversalDirectives` | Get directives that apply to all users (constitutional) |
+
+### Schema Awareness Tools (2)
+| Tool | Description |
+|------|-------------|
+| `ekkOS_IndexSchema` | Index database schemas (Supabase, Prisma, TypeScript) |
+| `ekkOS_GetSchema` | Get schema for a specific table/type |
 
-### Plan Management
+### Plan Management (8)
 | Tool | Description |
 |------|-------------|
 | `ekkOS_Plan` | Create structured task plan |
@@ -153,7 +209,7 @@ You: Task(subagent_type="extension-manager", prompt="Bump version...")
 | `ekkOS_Templates` | List available templates |
 | `ekkOS_FromTemplate` | Create plan from template |
 
-### Secrets Management (Layer 11)
+### Secrets Management (5)
 | Tool | Description |
 |------|-------------|
 | `ekkOS_StoreSecret` | Encrypt and store sensitive data (AES-256-GCM) |
@@ -162,6 +218,39 @@ You: Task(subagent_type="extension-manager", prompt="Bump version...")
 | `ekkOS_DeleteSecret` | Permanently delete a secret |
 | `ekkOS_RotateSecret` | Update secret with new value |
 
+### Project/Sync Tools (4)
+| Tool | Description |
+|------|-------------|
+| `ekkOS_ProjectInit` | Initialize ekkOS for a new project |
+| `ekkOS_Ingest` | Bulk ingest data into memory layers |
+| `ekkOS_Snapshot` | Create point-in-time snapshot of memory state |
+| `ekkOS_Sync` | Sync local and cloud memory state |
+
+### Session Management (1)
+| Tool | Description |
+|------|-------------|
+| `ekkOS_Session` | Manage L1 Working Memory sessions (start/resume/end) |
+
+### Learning Tools (2)
+| Tool | Description |
+|------|-------------|
+| `ekkOS_Learn` | Auto-learning from corrections, successes, observations |
+| `ekkOS_ReviewLearning` | Review pending learning candidates, approve/reject patterns |
+
+### Relationship Tools (2)
+| Tool | Description |
+|------|-------------|
+| `ekkOS_Link` | Create relationships between patterns |
+| `ekkOS_Playbook` | Manage ordered sequences of patterns (workflows) |
+
+### PROMETHEUS Tools (4)
+| Tool | Description |
+|------|-------------|
+| `ekkOS_Delta` | Compute improvement score using Δ_prometheus formula |
+| `ekkOS_MetaState` | System introspection ("I know what I know") |
+| `ekkOS_Goal` | Manage persistent objectives and success criteria |
+| `ekkOS_Strategy` | Context-aware strategy selection for tasks |
+
 ---
 
 ## Proactive Tool Triggers (MEMORIZE THESE)
@@ -204,6 +293,28 @@ You: Task(subagent_type="extension-manager", prompt="Bump version...")
 - Need to retrieve stored credentials
 - User asks "do you have my X key?"
 
+### Always Use Context Preservation When:
+- PreCompact hook fires (auto-triggered)
+- See `<ekkos-context-preserved>` tag (auto-restore)
+- RULE 6 activation
+
+### Always Use Learning Tools When:
+- User corrects you (ekkOS_Learn mode: correction)
+- Solution succeeds (ekkOS_Learn mode: success)
+- Discover insight (ekkOS_Learn mode: observe)
+- Review pending patterns (ekkOS_ReviewLearning)
+
+### Always Use Relationship Tools When:
+- Patterns are sequential (ekkOS_Link type: leads_to)
+- Creating workflows (ekkOS_Playbook)
+- Patterns are alternatives (ekkOS_Link type: alternative)
+
+### Always Use PROMETHEUS Tools When:
+- Evaluating system improvement (ekkOS_Delta)
+- Self-assessment needed (ekkOS_MetaState)
+- Setting objectives (ekkOS_Goal)
+- Choosing approach (ekkOS_Strategy)
+
 ---
 
 ## 11-Layer Memory Architecture
@@ -253,20 +364,21 @@ Call `ekkOS_Directive` when user says:
 **EVERY response MUST end with this footer:**
 ```
 ---
-{IDE} ({Model}) · 🧠 **ekkOS_™** · Turn {N} · 📅 {Timestamp}
+{IDE} ({Model}) · 🧠 **ekkOS_™** · Turn {N} · {SessionName} · 📅 {Timestamp}
 ```
 
 **How to detect values:**
 - **IDE**: Claude Code, Cursor, Windsurf, etc. (from environment)
 - **Model**: Sonnet 4.5, Opus 4.5, etc. (from your model name)
 - **Turn Number**: From hook header (e.g., "Turn 47") - starts at 0 for each new session
+- **Session Name**: From hook header (e.g., "sol-gem-dig") - human-readable session identifier
 - **Timestamp**: From hook header (accurate local time in EST)
 
 **Examples:**
-- `Claude Code (Sonnet 4.5) · 🧠 **ekkOS_™** · Turn 12 · 📅 2026-01-09 4:50 PM EST`
-- `Cursor (Claude Sonnet 4) · 🧠 **ekkOS_™** · Turn 5 · 📅 2026-01-09 10:15 AM EST`
+- `Claude Code (Sonnet 4.5) · 🧠 **ekkOS_™** · Turn 12 · cosmic-penguin-runs · 📅 2026-01-09 4:50 PM EST`
+- `Cursor (Claude Sonnet 4) · 🧠 **ekkOS_™** · Turn 5 · bright-falcon-soars · 📅 2026-01-09 10:15 AM EST`
 
-**The hook header shows:** `🧠 ekkOS Memory | Turn {N} | Session: {ID} | {timestamp}`
+**The hook header shows:** `🧠 ekkOS Memory | Turn {N} | {Context%} | {SessionName} | {timestamp}`
 
 ---