@ekkos/cli 0.3.3 → 1.0.1

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}`
 
 ---
 

package/templates/ekkos-manifest.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://ekkos.dev/schemas/manifest-v1.json",
   "manifestVersion": "1.0.0",
-  "generatedAt": "2026-02-04T04:30:49.260Z",
+  "generatedAt": "2026-02-18T04:29:25.535Z",
   "platforms": {
     "darwin": {
       "configDir": "~/.ekkos",
@@ -68,14 +68,14 @@
           "source": "hooks/user-prompt-submit.sh",
           "destination": "user-prompt-submit.sh",
           "description": "User prompt submit hook (Unix)",
-          "checksum": "38aa190d08e2c24129e7f653732a860693fbd2a7015e59226aec57e8b3659114",
+          "checksum": "ef294d0088a94c6588a91fc91e6cc06a14dd46bc83ca09d73c64abfb11984f40",
           "executable": true
         },
         {
           "source": "hooks/stop.sh",
           "destination": "stop.sh",
           "description": "Session stop hook (Unix)",
-          "checksum": "fd436ea847bf6fbe367f8aa61ddf6d97e8605837badc3af8d433b59599ef6615",
+          "checksum": "f3b4495c0c2bbdf5bfef762568faec7b70b41b463dad4c88b37cf7ee32b5257d",
           "executable": true
         },
         {
@@ -124,14 +124,14 @@
           "source": "hooks/lib/contract.sh",
           "destination": "lib/contract.sh",
           "description": "Hook contract library",
-          "checksum": "1d86128a2a4a25e653a02c4eb08dbfd28db53063c618cd43b85f0603a135e8b2",
+          "checksum": "3ef16930ba10cd37a1c5fa8469ec13a6a84cadb882d3f9a96c72da875ba07fc7",
           "executable": true
         },
         {
           "source": "hooks/lib/state.sh",
           "destination": "lib/state.sh",
           "description": "Hook state management library",
-          "checksum": "ba72c00a1fb0f6768e37aff754ad6ac0e8e20aa0b9b393193e2d92357cac5a71",
+          "checksum": "99223ce9b869d78762084ff184327fa2814af7a16e5f2ac9619af43b5e551d7c",
           "executable": true
         }
       ]

package/templates/hooks/lib/contract.sh

@@ -78,7 +78,7 @@ write_turn_contract() {
   "retrieved_directive_ids": $directive_array,
   "timestamp": "$timestamp",
   "query_hash": "$query_hash",
-  "ekkos_strict": ${EKKOS_STRICT:-0}
+  "ekkos_strict": ${EKKOS_STRICT:-1}
 }
 EOF
 
@@ -134,7 +134,7 @@ cleanup_turn_contract() {
 
 # Check if strict mode is enabled
 is_strict_mode() {
-  [ "${EKKOS_STRICT:-0}" = "1" ]
+  [ "${EKKOS_STRICT:-1}" = "1" ]  # DEFAULT: ON
 }
 
 # Generate strict mode blocker message for Claude Code
@@ -157,50 +157,57 @@ EOF
 }
 
 # Validate PatternGuard coverage (returns 0-100)
+# PORTABLE: Works on macOS without Perl regex (grep -P)
 calculate_pattern_guard_coverage() {
   local assistant_response="$1"
   local pattern_ids="$2"  # Comma-separated
 
-  # Count total patterns
-  local total_count
-  total_count=$(echo "$pattern_ids" | tr ',' '\n' | grep -c '.' || echo 0)
+  # Count total patterns - more robust counting
+  local total_count=0
+  if [ -n "$pattern_ids" ]; then
+    total_count=$(echo "$pattern_ids" | tr ',' '\n' | grep -v '^$' | wc -l | tr -d ' ')
+  fi
 
   if [ "$total_count" -eq 0 ]; then
     echo "100"  # No patterns = 100% coverage by definition
     return 0
   fi
 
-  # Extract acknowledged IDs from [ekkOS_SELECT] and [ekkOS_SKIP] blocks
+  # Extract acknowledged IDs using portable awk (works on macOS and Linux)
   local acknowledged_count=0
 
-  # Check SELECT block
-  local select_block
-  select_block=$(echo "$assistant_response" | grep -ozP '\[ekkOS_SELECT\][\s\S]*?\[/ekkOS_SELECT\]' 2>/dev/null | tr '\0' '\n' || true)
-  if [ -n "$select_block" ]; then
-    local select_count
-    select_count=$(echo "$select_block" | grep -oE 'id:\s*[a-f0-9-]+' | wc -l | tr -d ' ')
-    acknowledged_count=$((acknowledged_count + select_count))
-  fi
-
-  # Check SKIP block
-  local skip_block
-  skip_block=$(echo "$assistant_response" | grep -ozP '\[ekkOS_SKIP\][\s\S]*?\[/ekkOS_SKIP\]' 2>/dev/null | tr '\0' '\n' || true)
-  if [ -n "$skip_block" ]; then
-    local skip_count
-    skip_count=$(echo "$skip_block" | grep -oE 'id:\s*[a-f0-9-]+' | wc -l | tr -d ' ')
-    acknowledged_count=$((acknowledged_count + skip_count))
-  fi
+  # Use awk to extract SELECT block and count IDs - PORTABLE approach
+  local select_count=0
+  select_count=$(echo "$assistant_response" | awk '
+    /\[ekkOS_SELECT\]/{in_block=1; next}
+    /\[\/ekkOS_SELECT\]/{in_block=0}
+    in_block && /id:/{count++}
+    END{print count+0}
+  ')
+  acknowledged_count=$((acknowledged_count + select_count))
+
+  # Use awk to extract SKIP block and count IDs
+  local skip_count=0
+  skip_count=$(echo "$assistant_response" | awk '
+    /\[ekkOS_SKIP\]/{in_block=1; next}
+    /\[\/ekkOS_SKIP\]/{in_block=0}
+    in_block && /id:/{count++}
+    END{print count+0}
+  ')
+  acknowledged_count=$((acknowledged_count + skip_count))
 
   # Legacy: Check for [ekkOS_APPLY] markers (fallback)
   if [ "$acknowledged_count" -eq 0 ]; then
     local apply_count
-    apply_count=$(echo "$assistant_response" | grep -c '\[ekkOS_APPLY\]' || echo 0)
-    acknowledged_count=$apply_count
+    apply_count=$(echo "$assistant_response" | grep -c '\[ekkOS_APPLY\]' 2>/dev/null || echo 0)
+    acknowledged_count=$((acknowledged_count + apply_count))
   fi
 
   # Calculate coverage percentage
-  local coverage
-  coverage=$((acknowledged_count * 100 / total_count))
+  local coverage=0
+  if [ "$total_count" -gt 0 ]; then
+    coverage=$((acknowledged_count * 100 / total_count))
+  fi
 
   # Cap at 100%
   if [ "$coverage" -gt 100 ]; then
@@ -255,11 +262,16 @@ EOF
 }
 
 # Determine if turn is compliant
+# ROBUST: Handles edge cases with non-numeric or empty values
 is_turn_compliant() {
-  local retrieval_ok="$1"
-  local pattern_guard_coverage="$2"
-  local footer_present="$3"
-  local pattern_count="$4"
+  local retrieval_ok="${1:-true}"
+  local pattern_guard_coverage="${2:-100}"
+  local footer_present="${3:-true}"
+  local pattern_count="${4:-0}"
+
+  # Sanitize numeric values (default to safe values)
+  pattern_guard_coverage=$(echo "$pattern_guard_coverage" | grep -oE '^[0-9]+$' || echo "100")
+  pattern_count=$(echo "$pattern_count" | grep -oE '^[0-9]+$' || echo "0")
 
   # Retrieval must have succeeded
   if [ "$retrieval_ok" != "true" ]; then

package/templates/hooks/lib/count-tokens.cjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * Token counter for Claude Code hooks
+ * Extracts ACTUAL token data from Anthropic API usage field
+ *
+ * The transcript contains the real usage data from each API response:
+ * - input_tokens: new tokens in this request
+ * - cache_read_input_tokens: cached tokens from previous turns
+ * - cache_creation_input_tokens: tokens added to cache
+ *
+ * Usage:
+ *   node count-tokens.cjs <transcript.jsonl>          -> outputs total token count
+ *   node count-tokens.cjs <transcript.jsonl> --json   -> outputs full breakdown as JSON
+ */
+
+const fs = require('fs');
+
+const filePath = process.argv[2];
+const outputJson = process.argv.includes('--json');
+
+if (!filePath) {
+  console.error('Usage: count-tokens.cjs <transcript.jsonl> [--json]');
+  process.exit(1);
+}
+
+if (!fs.existsSync(filePath)) {
+  console.error(`[count-tokens] ERROR: File not found: ${filePath}`);
+  process.exit(1);
+}
+
+/**
+ * Extract token breakdown from the most recent assistant message's usage field
+ * This is the authoritative data from Anthropic's API
+ */
+function getTokenBreakdown(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.trim().split('\n').filter(Boolean);
+
+  // Find the most recent assistant message with usage data
+  let latestUsage = null;
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+
+      if (entry.type === 'assistant' && entry.message?.usage) {
+        latestUsage = entry.message.usage;
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+
+  if (!latestUsage) {
+    return {
+      input_tokens: 0,
+      cache_read_tokens: 0,
+      cache_creation_tokens: 0,
+      total_tokens: 0,
+      output_tokens: 0
+    };
+  }
+
+  const inputTokens = latestUsage.input_tokens || 0;
+  const cacheRead = latestUsage.cache_read_input_tokens || 0;
+  const cacheCreation = latestUsage.cache_creation_input_tokens || 0;
+  const outputTokens = latestUsage.output_tokens || 0;
+
+  return {
+    input_tokens: inputTokens,
+    cache_read_tokens: cacheRead,
+    cache_creation_tokens: cacheCreation,
+    total_tokens: inputTokens + cacheRead + cacheCreation,
+    output_tokens: outputTokens
+  };
+}
+
+const breakdown = getTokenBreakdown(filePath);
+
+if (outputJson) {
+  // Output full breakdown as JSON (for API)
+  console.log(JSON.stringify(breakdown));
+} else {
+  // Output just the total (backward compatible)
+  console.log(breakdown.total_tokens);
+}

package/templates/hooks/lib/ekkos-reminders.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+# ═══════════════════════════════════════════════════════════════════════════
+# ekkOS Tool Usage Reminders - Inject proactive tool usage hints
+# ═══════════════════════════════════════════════════════════════════════════
+
+# Detect if user query suggests using specific ekkOS tools
+# Returns markdown reminders to inject into Claude's context
+
+get_ekkos_reminders() {
+  local query="$1"
+  local prev_response="$2"
+  local reminders=""
+
+  # Convert to lowercase for matching
+  query_lower=$(echo "$query" | tr '[:upper:]' '[:lower:]')
+  response_lower=$(echo "$prev_response" | tr '[:upper:]' '[:lower:]')
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ekkOS_Search - Before answering technical questions
+  # ═══════════════════════════════════════════════════════════════════════════
+  if echo "$query_lower" | grep -qE "(how do|how to|what is|why|explain|security|authentication|database|rls|deployment|error|bug|fix)"; then
+    reminders+="🧠 **ekkOS_Search Required**: Search memory before answering technical questions\n"
+  fi
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ekkOS_Forge - When fixing bugs or learning
+  # ═══════════════════════════════════════════════════════════════════════════
+  if echo "$response_lower" | grep -qE "(fixed|solved|resolved|bug|issue|error|migration|implemented|created|updated)"; then
+    reminders+="🔨 **ekkOS_Forge Recommended**: Forge pattern after fixing bugs or implementing solutions\n"
+  fi
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ekkOS_Directive - User preferences
+  # ═══════════════════════════════════════════════════════════════════════════
+  if echo "$query_lower" | grep -qE "(always|never|dont|don't|prefer|avoid|should not|shouldn't)"; then
+    directive_type="PREFER"
+    if echo "$query_lower" | grep -qE "(always|must)"; then
+      directive_type="MUST"
+    elif echo "$query_lower" | grep -qE "(never|dont|don't|avoid|should not)"; then
+      directive_type="NEVER"
+    fi
+    reminders+="📋 **ekkOS_Directive Required**: User stated a preference - save as ${directive_type} directive\n"
+  fi
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ekkOS_Conflict - Destructive operations
+  # ═══════════════════════════════════════════════════════════════════════════
+  if echo "$query_lower" | grep -qE "(delete|remove|drop|truncate|destroy|wipe)"; then
+    reminders+="⚠️  **ekkOS_Conflict Required**: Check for conflicts before destructive operations\n"
+  fi
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ekkOS_Plan - Complex multi-step tasks
+  # ═══════════════════════════════════════════════════════════════════════════
+  if echo "$query_lower" | grep -qE "(implement|build|create.*feature|add.*functionality|refactor|migrate)"; then
+    reminders+="📝 **ekkOS_Plan Recommended**: Create structured plan for multi-step implementation\n"
+  fi
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ekkOS_StoreSecret - Credentials shared
+  # ═══════════════════════════════════════════════════════════════════════════
+  if echo "$query_lower" | grep -qE "(api.?key|token|password|secret|credential|github.*key|openai.*key)"; then
+    reminders+="🔐 **ekkOS_StoreSecret Available**: Use to securely store credentials (AES-256-GCM)\n"
+  fi
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ekkOS_Recall - Past conversations
+  # ═══════════════════════════════════════════════════════════════════════════
+  if echo "$query_lower" | grep -qE "(yesterday|last week|previously|we discussed|earlier|before)"; then
+    reminders+="🕐 **ekkOS_Recall Available**: Retrieve past conversations by time\n"
+  fi
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ekkOS_Codebase - Project-specific search
+  # ═══════════════════════════════════════════════════════════════════════════
+  if echo "$query_lower" | grep -qE "(in this project|in our codebase|where is.*defined|find.*file)"; then
+    reminders+="📂 **ekkOS_Codebase Available**: Search project-specific memory\n"
+  fi
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ekkOS_Export - Backup request
+  # ═══════════════════════════════════════════════════════════════════════════
+  if echo "$query_lower" | grep -qE "(export|backup|download|save.*memory|portable)"; then
+    reminders+="💾 **ekkOS_Export Available**: Export all patterns/directives as portable JSON\n"
+  fi
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ekkOS_Summary - Show activity
+  # ═══════════════════════════════════════════════════════════════════════════
+  if echo "$query_lower" | grep -qE "(what did.*do|ekkos.*activity|memory.*stats|show.*patterns)"; then
+    reminders+="📊 **ekkOS_Summary Available**: Show recent ekkOS activity\n"
+  fi
+
+  echo "$reminders"
+}
+
+# Export function
+export -f get_ekkos_reminders