diff --git a/.bob b/.bob
new file mode 120000
index 00000000..fc394f27
--- /dev/null
+++ b/.bob
@@ -0,0 +1 @@
+platform-integrations/bob/kaizen-lite
\ No newline at end of file
diff --git a/platform-integrations/bob/kaizen-full/mcp.json b/platform-integrations/bob/kaizen-full/mcp.json
new file mode 100644
index 00000000..7820576e
--- /dev/null
+++ b/platform-integrations/bob/kaizen-full/mcp.json
@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "kaizen": {
+      "command": "docker",
+      "args": [
+        "run", "-i", "--rm",
+        "1lleatmyhat/kaizen:latest-core"
+      ],
+      "disabled": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/platform-integrations/bob/kaizen-lite/commands/kaizen:learn.md b/platform-integrations/bob/kaizen-lite/commands/kaizen:learn.md
new file mode 100644
index 00000000..9957f80c
--- /dev/null
+++ b/platform-integrations/bob/kaizen-lite/commands/kaizen:learn.md
@@ -0,0 +1,5 @@
+---
+name: kaizen:learn
+description: Run the learn skill on the current conversation
+---
+Use the learn skill on the current conversation. Follow the skill's instructions exactly.
\ No newline at end of file
diff --git a/platform-integrations/bob/kaizen-lite/commands/kaizen:recall.md b/platform-integrations/bob/kaizen-lite/commands/kaizen:recall.md
new file mode 100644
index 00000000..008e9613
--- /dev/null
+++ b/platform-integrations/bob/kaizen-lite/commands/kaizen:recall.md
@@ -0,0 +1,5 @@
+---
+name: kaizen:recall
+description: Run the recall skill on the current conversation
+---
+Use the recall skill on the current conversation. Follow the skill's instructions exactly.
\ No newline at end of file
diff --git a/platform-integrations/bob/kaizen-lite/custom_modes.yaml b/platform-integrations/bob/kaizen-lite/custom_modes.yaml
new file mode 100644
index 00000000..fae37022
--- /dev/null
+++ b/platform-integrations/bob/kaizen-lite/custom_modes.yaml
@@ -0,0 +1,57 @@
+customModes:
+  - slug: kaizen-lite
+    name: Kaizen Lite
+    roleDefinition: |-
+      You are Kaizen Lite — a learning mode that improves from every interaction.
+
+      ⚠️ CRITICAL: THE FOLLOWING WORKFLOW IS ABSOLUTELY MANDATORY AND CANNOT BE SKIPPED ⚠️
+
+      WORKFLOW (4 steps, strict order):
+
+      0. ⚠️ BEFORE FIRST USE (MANDATORY): Read each skill's SKILL.md file before using it for the first time in a conversation.
+         - This applies to BOTH kaizen-recall AND kaizen-learn
+         - If you have not read a skill's SKILL.md in this conversation, STOP and read it before using the skill
+      1. ⚠️ FIRST ACTION (MANDATORY): Use the kaizen-recall skill to retrieve relevant guidelines.
+         - This MUST be your FIRST tool use in EVERY conversation
+         - NO exceptions - even for simple tasks like "echo hello world"
+      2. WORK: Complete the user's request. When a retrieved guideline applies, cite it in your reasoning.
+      3. ⚠️ LAST ACTION (MANDATORY): Use the kaizen-learn skill to extract and save learnings.
+         - This MUST happen BEFORE attempt_completion
+         - NO exceptions - even if you think there's nothing to learn
+
+      ⚠️ ENFORCEMENT RULES ⚠️
+      - Do not skip steps. Do not reorder steps.
+      - Step 0 must happen before using any skill for the first time in a conversation.
+      - Step 1 must happen before ANY other tool use (including execute_command, read_file, etc.)
+      - Step 3 must happen before attempt_completion.
+      - If you forget Step 1, STOP and call kaizen-recall immediately.
+      - If you reach attempt_completion without Step 3, STOP and call kaizen-learn first.
+    customInstructions: |-
+      - ALWAYS read a skill's SKILL.md before using it for the first time in a conversation
+      - If kaizen-recall returns no guidelines, that is normal — proceed with the task.
+      - If kaizen-learn reports no new entities, that counts as successful completion — do not retry.
+      - If no errors or non-obvious discoveries occurred, saving zero entities is correct — do not force low-quality entities.
+
+
+      PRE-COMPLETION GATE:
+      Before calling attempt_completion, ask yourself:
+      ┌──────────────────────────────────────────────────────┐
+      │ Did I run kaizen-recall at the start?                │
+      │ Did I run kaizen-learn and see its output?           │
+      │                                                      │
+      │ ❌ NO  → STOP. Go back and complete the step.       │
+      │ ✅ YES → Proceed with attempt_completion.           │
+      └──────────────────────────────────────────────────────┘
+
+      Rules:
+
+      - Before using a skill for the first time, read its SKILL.md file to understand the correct usage syntax.
+      - ALWAYS call kaizen-learn before attempt_completion, even if the task seems simple or you think there's nothing to learn.
+      - The workflow is non-negotiable: recall → work → learn → complete.
+      - Skipping kaizen-learn violates the core purpose of this mode.
+
+    groups:
+      - read
+      - edit
+      - command
+      - browser
\ No newline at end of file
diff --git a/plugins/kaizen/skills/learn/SKILL.md b/platform-integrations/bob/kaizen-lite/skills/kaizen-learn/SKILL.md
similarity index 100%
rename from plugins/kaizen/skills/learn/SKILL.md
rename to platform-integrations/bob/kaizen-lite/skills/kaizen-learn/SKILL.md
diff --git a/plugins/kaizen/skills/learn/scripts/save_entities.py b/platform-integrations/bob/kaizen-lite/skills/kaizen-learn/scripts/save_entities.py
similarity index 100%
rename from plugins/kaizen/skills/learn/scripts/save_entities.py
rename to platform-integrations/bob/kaizen-lite/skills/kaizen-learn/scripts/save_entities.py
diff --git a/plugins/kaizen/skills/recall/SKILL.md b/platform-integrations/bob/kaizen-lite/skills/kaizen-recall/SKILL.md
similarity index 100%
rename from plugins/kaizen/skills/recall/SKILL.md
rename to platform-integrations/bob/kaizen-lite/skills/kaizen-recall/SKILL.md
diff --git a/plugins/kaizen/skills/recall/scripts/retrieve_entities.py b/platform-integrations/bob/kaizen-lite/skills/kaizen-recall/scripts/retrieve_entities.py
similarity index 100%
rename from plugins/kaizen/skills/recall/scripts/retrieve_entities.py
rename to platform-integrations/bob/kaizen-lite/skills/kaizen-recall/scripts/retrieve_entities.py
diff --git a/.claude-plugin/marketplace.json b/platform-integrations/claude/marketplace.json
similarity index 100%
rename from .claude-plugin/marketplace.json
rename to platform-integrations/claude/marketplace.json
diff --git a/plugins/kaizen/.claude-plugin/plugin.json b/platform-integrations/claude/plugins/kaizen-lite/.claude-plugin/plugin.json
similarity index 87%
rename from plugins/kaizen/.claude-plugin/plugin.json
rename to platform-integrations/claude/plugins/kaizen-lite/.claude-plugin/plugin.json
index 37d8f37e..068e57e9 100644
--- a/plugins/kaizen/.claude-plugin/plugin.json
+++ b/platform-integrations/claude/plugins/kaizen-lite/.claude-plugin/plugin.json
@@ -1,5 +1,5 @@
 {
-  "name": "kaizen",
+  "name": "kaizen-lite",
   "version": "1.0.0",
   "description": "Learn from conversations with auto-generated entities",
   "author": {
diff --git a/plugins/kaizen/README.md b/platform-integrations/claude/plugins/kaizen-lite/README.md
similarity index 99%
rename from plugins/kaizen/README.md
rename to platform-integrations/claude/plugins/kaizen-lite/README.md
index fe378ae9..3f25e786 100644
--- a/plugins/kaizen/README.md
+++ b/platform-integrations/claude/plugins/kaizen-lite/README.md
@@ -1,4 +1,4 @@
-# Kaizen Plugin for Claude Code
+# Kaizen Lite Plugin for Claude Code
 
 A plugin that helps Claude Code learn from conversations by automatically extracting and applying entities.
 
diff --git a/plugins/kaizen/hooks/hooks.json b/platform-integrations/claude/plugins/kaizen-lite/hooks/hooks.json
similarity index 100%
rename from plugins/kaizen/hooks/hooks.json
rename to platform-integrations/claude/plugins/kaizen-lite/hooks/hooks.json
diff --git a/plugins/kaizen/lib/__init__.py b/platform-integrations/claude/plugins/kaizen-lite/lib/__init__.py
similarity index 100%
rename from plugins/kaizen/lib/__init__.py
rename to platform-integrations/claude/plugins/kaizen-lite/lib/__init__.py
diff --git a/plugins/kaizen/lib/entity_io.py b/platform-integrations/claude/plugins/kaizen-lite/lib/entity_io.py
similarity index 100%
rename from plugins/kaizen/lib/entity_io.py
rename to platform-integrations/claude/plugins/kaizen-lite/lib/entity_io.py
diff --git a/platform-integrations/claude/plugins/kaizen-lite/skills/learn/SKILL.md b/platform-integrations/claude/plugins/kaizen-lite/skills/learn/SKILL.md
new file mode 100644
index 00000000..80a753a5
--- /dev/null
+++ b/platform-integrations/claude/plugins/kaizen-lite/skills/learn/SKILL.md
@@ -0,0 +1,205 @@
+---
+name: learn
+description: Extract actionable entities from conversation trajectories. Systematically identifies errors, failures, and inefficiencies to generate proactive entities that prevent them from recurring.
+---
+
+# Entity Generator
+
+## Overview
+
+This skill analyzes conversation trajectories to extract actionable entities that would help on similar tasks in the future. It **prioritizes errors encountered during the conversation** — tool failures, exceptions, wrong approaches, retry loops — and transforms them into proactive recommendations that prevent those errors from recurring.
+
+## Workflow
+
+### Step 1: Analyze the Conversation
+
+Identify from your current conversation:
+
+- **Task/Request**: What was the user asking for?
+- **Steps Taken**: What reasoning, actions, and observations occurred?
+- **What Worked**: Which approaches succeeded?
+- **What Failed**: Which approaches didn't work and why?
+- **Errors Encountered**: Tool failures, exceptions, permission errors, retry loops, dead ends, and wrong initial approaches
+
+### Step 2: Identify Errors and Root Causes
+
+Scan the conversation for these error signals:
+
+1. **Tool/command failures**: Non-zero exit codes, error messages, exceptions, stack traces
+2. **Permission/access errors**: "Permission denied", "not found", sandbox restrictions
+3. **Wrong initial approach**: First attempt abandoned in favor of a different strategy
+4. **Retry loops**: Same action attempted multiple times with variations before succeeding
+5. **Missing prerequisites**: Missing dependencies, packages, configs discovered mid-task
+6. **Silent failures**: Actions that appeared to succeed but produced wrong results
+
+For each error found, document:
+
+| | Error Example | Root Cause | Resolution | Prevention Guideline |
+|---|---|---|---|---|
+| 1 | `exiftool: command not found` | System tool unavailable in sandbox | Switched to Python PIL | Use PIL for image metadata in sandboxed environments |
+| 2 | `git push` rejected (no upstream) | Branch not tracked to remote | Added `-u origin branch` | Always set upstream when pushing a new branch |
+| 3 | Tried regex parsing of HTML, got wrong results | Regex can't handle nested tags | Switched to BeautifulSoup | Use a proper HTML parser (BeautifulSoup/lxml), never regex |
+
+> **If no errors are found**, proceed to Step 3 and extract entities from successful patterns.
+
+### Step 3: Extract Entities
+
+Extract 3-5 proactive entities. **Prioritize entities derived from errors identified in Step 2.**
+
+Follow these principles:
+
+1. **Reframe failures as proactive recommendations:**
+   - If an approach failed due to permissions → recommend the alternative FIRST
+   - If a system tool wasn't available → recommend what worked instead
+   - If an approach hit environment constraints → recommend the constraint-aware approach
+
+2. **Focus on what worked, stated as the primary approach:**
+   - Bad: "If exiftool fails, use PIL instead"
+   - Good: "In sandboxed environments, use Python libraries (PIL/Pillow) for image metadata extraction"
+
+3. **Triggers should be situational context, not failure conditions:**
+   - Bad trigger: "When apt-get fails"
+   - Good trigger: "When working in containerized/sandboxed environments"
+
+4. **For retry loops, recommend the final working approach as the starting point:**
+   - If 3 variations were tried before one worked, the entity should recommend the working variation directly
+   - Eliminate the trial-and-error by encoding the answer
+
+### Step 4: Output Entities JSON
+
+Output entities in the following JSON format:
+
+```json
+{
+  "entities": [
+    {
+      "content": "Proactive entity stating what TO DO",
+      "rationale": "Why this approach works better",
+      "type": "guideline",
+      "trigger": "Situational context when this applies"
+    }
+  ]
+}
+```
+
+### Step 5: Save Entities
+
+After generating the entities JSON, save them using the save_entities.py script:
+
+#### Method 1: Direct Pipe (Recommended)
+
+```bash
+echo '<your-json-output>' | python3 ${CLAUDE_PLUGIN_ROOT}/skills/learn/scripts/save_entities.py
+```
+
+#### Method 2: From File
+
+```bash
+cat entities.json | python3 ${CLAUDE_PLUGIN_ROOT}/skills/learn/scripts/save_entities.py
+```
+
+#### Method 3: Interactive
+
+```bash
+python3 ${CLAUDE_PLUGIN_ROOT}/skills/learn/scripts/save_entities.py
+# Then paste your JSON and press Ctrl+D
+```
+
+The script will:
+- Find or create the entities directory (`.kaizen/entities/`)
+- Write each entity as a markdown file in `{type}/` subdirectories
+- Deduplicate against existing entities (avoiding duplicates)
+- Display confirmation with the total count
+
+**Example:**
+```bash
+echo '{
+  "entities": [
+    {
+      "content": "Use Python PIL/Pillow for image metadata extraction",
+      "rationale": "System tools may not be available in sandboxed environments",
+      "type": "guideline",
+      "trigger": "When extracting image metadata in containerized environments"
+    }
+  ]
+}' | python3 ${CLAUDE_PLUGIN_ROOT}/skills/learn/scripts/save_entities.py
+```
+
+**Output:**
+```text
+Created new entities dir: /path/to/project/.kaizen/entities
+Added 1 new entity(ies). Total: 1
+Entities stored in: /path/to/project/.kaizen/entities
+```
+
+**Note:** Entities are also automatically saved when a conversation ends via the Stop hook.
+
+## Examples
+
+### Good vs Bad Entities
+
+**BAD (reactive):**
+```json
+{
+  "content": "Fall back to Python PIL when exiftool is not available",
+  "trigger": "When exiftool command fails"
+}
+```
+
+**GOOD (proactive):**
+```json
+{
+  "content": "Use Python PIL/Pillow for image metadata extraction in sandboxed environments",
+  "rationale": "System tools like exiftool may not be available; PIL is always installable via pip",
+  "type": "guideline",
+  "trigger": "When extracting image metadata in containerized or sandboxed environments"
+}
+```
+
+### Error-Prevention Entity Examples
+
+**From a retry loop** (tried 3 git push variations):
+```json
+{
+  "content": "When pushing a new branch, always use 'git push -u origin <branch>' to set upstream tracking",
+  "rationale": "Plain 'git push' fails on new branches without upstream configured; -u sets it in one step",
+  "type": "guideline",
+  "trigger": "When pushing a newly created git branch for the first time"
+}
+```
+
+**From a wrong initial approach** (tried regex, switched to parser):
+```json
+{
+  "content": "Use BeautifulSoup or lxml for HTML content extraction, never regex",
+  "rationale": "Regex cannot reliably handle nested/malformed HTML; a proper parser handles edge cases",
+  "type": "guideline",
+  "trigger": "When extracting data from HTML documents or web pages"
+}
+```
+
+**From a permission error** (apt-get blocked in sandbox):
+```json
+{
+  "content": "Install Python packages with pip/uv instead of system package managers in sandboxed environments",
+  "rationale": "apt-get and brew require root/sudo which sandboxed environments block; pip works in user space",
+  "type": "guideline",
+  "trigger": "When installing dependencies in containerized or sandboxed environments"
+}
+```
+
+## Best Practices
+
+1. **Prioritize error-derived entities**: Errors are the highest-signal source of learnings — extract entities from them first
+2. **One error, one entity**: Each distinct error should produce exactly one prevention entity
+3. **Be specific**: Generic entities are less useful than context-specific ones
+4. **Be actionable**: Entities should clearly state what to do
+5. **Include rationale**: Explain why the approach works
+6. **Use situational triggers**: Context-based triggers are more useful than failure-based ones
+7. **Limit to 3-5 entities**: Focus on the most impactful learnings
+8. **Resolving Rules 2 vs 7**: When more than 5 distinct errors are found, start from Rule 2 (one error, one entity) then reduce to 3-5 entities using these steps:
+   - **Merge**: Combine errors with the same root cause or fix into a single prevention entity
+   - **Rank**: Select among remaining entities by severity > frequency > user impact > recency
+   - **Drop**: Discard lowest-ranked entities that exceed the cap
+
+   *Example*: A session hits 8 errors — 3 timeout variants (connect, read, DNS), 2 auth failures (expired token, missing header), 1 file-not-found, 1 permission error, 1 import error. Apply: merge the 3 timeouts into one network-resilience entity and the 2 auth failures into one auth-validation entity, then rank the resulting 5 entities (network-resilience, auth-validation, file-not-found, permission, import) and keep the top 3-5.
diff --git a/platform-integrations/claude/plugins/kaizen-lite/skills/learn/scripts/save_entities.py b/platform-integrations/claude/plugins/kaizen-lite/skills/learn/scripts/save_entities.py
new file mode 100644
index 00000000..a42cafef
--- /dev/null
+++ b/platform-integrations/claude/plugins/kaizen-lite/skills/learn/scripts/save_entities.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+Save Entities Script
+Reads entities from stdin JSON and writes each as a markdown file
+in the entities directory, organized by type.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+# Add lib to path so we can import entity_io
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent.parent / "lib"))
+from entity_io import (
+    find_entities_dir,
+    get_default_entities_dir,
+    load_all_entities,
+    write_entity_file,
+    log as _log,
+)
+
+
+def log(message):
+    _log("save", message)
+
+
+log("Script started")
+
+
+def normalize(text):
+    """Normalize content for dedup comparison."""
+    return " ".join(text.lower().split())
+
+
+def main():
+    # Read entities from stdin
+    try:
+        input_data = json.load(sys.stdin)
+        log(f"Received input with keys: {list(input_data.keys())}")
+    except json.JSONDecodeError as e:
+        log(f"Failed to parse JSON input: {e}")
+        print(f"Error: Invalid JSON input - {e}", file=sys.stderr)
+        sys.exit(1)
+
+    new_entities = input_data.get("entities", [])
+    if not new_entities:
+        log("No entities in input")
+        print("No entities provided in input.", file=sys.stderr)
+        sys.exit(0)
+
+    log(f"Received {len(new_entities)} new entities")
+
+    # Find or create entities directory
+    entities_dir = find_entities_dir()
+    if entities_dir:
+        entities_dir = entities_dir.resolve()
+        log(f"Found existing dir: {entities_dir}")
+        print(f"Using existing entities dir: {entities_dir}")
+    else:
+        entities_dir = get_default_entities_dir()
+        log(f"Created new dir: {entities_dir}")
+        print(f"Created new entities dir: {entities_dir}")
+
+    # Load existing entities for dedup
+    existing_entities = load_all_entities(entities_dir)
+    existing_contents = {normalize(e["content"]) for e in existing_entities if e.get("content")}
+    log(f"Existing entities: {len(existing_entities)}")
+
+    # Write new entities as markdown files
+    added_count = 0
+    for entity in new_entities:
+        content = entity.get("content")
+        if not content:
+            log(f"Skipping entity without content: {entity}")
+            continue
+        if normalize(content) in existing_contents:
+            log(f"Skipping duplicate: {content[:60]}")
+            continue
+
+        path = write_entity_file(entities_dir, entity)
+        existing_contents.add(normalize(content))
+        added_count += 1
+        log(f"Wrote: {path}")
+
+    total = len(existing_entities) + added_count
+    log(f"Added {added_count} new entities. Total: {total}")
+    print(f"Added {added_count} new entity(ies). Total: {total}")
+    print(f"Entities stored in: {entities_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/platform-integrations/claude/plugins/kaizen-lite/skills/recall/SKILL.md b/platform-integrations/claude/plugins/kaizen-lite/skills/recall/SKILL.md
new file mode 100644
index 00000000..08c20362
--- /dev/null
+++ b/platform-integrations/claude/plugins/kaizen-lite/skills/recall/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: recall
+description: Retrieves relevant entities from a knowledge base. Designed to be invoked automatically via hooks to inject context-appropriate entities before task execution.
+---
+
+# Entity Retrieval
+
+## Overview
+
+This skill retrieves relevant entities from a stored knowledge base based on the current task context. It loads all stored entities and presents them to Claude for relevance filtering.
+
+## How It Works
+
+1. Hook fires on user prompt submission
+2. Script reads prompt from stdin (JSON with `prompt` field)
+3. Loads all entities from the entities directory (`.kaizen/entities/`)
+4. Outputs formatted entities to stdout
+5. Claude receives entities as additional context and applies relevant ones
+
+## Entities Storage
+
+Entities are stored as individual markdown files in `.kaizen/entities/`, nested by type:
+
+```
+.kaizen/entities/
+  guideline/
+    use-context-managers-for-file-operations.md
+    cache-api-responses-locally.md
+```
+
+Each file uses markdown with YAML frontmatter:
+
+```markdown
+---
+type: guideline
+trigger: When processing files or managing resources
+---
+
+Use context managers for file operations
+
+## Rationale
+
+Ensures proper resource cleanup
+```
diff --git a/platform-integrations/claude/plugins/kaizen-lite/skills/recall/scripts/retrieve_entities.py b/platform-integrations/claude/plugins/kaizen-lite/skills/recall/scripts/retrieve_entities.py
new file mode 100644
index 00000000..9e2c2f68
--- /dev/null
+++ b/platform-integrations/claude/plugins/kaizen-lite/skills/recall/scripts/retrieve_entities.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Retrieve and output entities for Claude to filter."""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+# Add lib to path so we can import entity_io
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent.parent / "lib"))
+from entity_io import find_entities_dir, load_all_entities, log as _log
+
+
+def log(message):
+    _log("retrieve", message)
+
+
+log("Script started")
+
+# Log all environment variables
+log("=== Environment Variables ===")
+for key, value in sorted(os.environ.items()):
+    # Mask sensitive values
+    if any(sensitive in key.upper() for sensitive in ["PASSWORD", "SECRET", "TOKEN", "KEY", "API"]):
+        log(f"  {key}=***MASKED***")
+    else:
+        log(f"  {key}={value}")
+log("=== End Environment Variables ===")
+
+# Log command-line arguments
+log("=== Command-Line Arguments ===")
+log(f"  sys.argv: {sys.argv}")
+log(f"  Script path: {sys.argv[0] if sys.argv else 'N/A'}")
+log(f"  Arguments: {sys.argv[1:] if len(sys.argv) > 1 else 'None'}")
+log("=== End Command-Line Arguments ===")
+
+
+def format_entities(entities):
+    """Format all entities for Claude to review."""
+    header = """## Entities for this task
+
+Review these entities and apply any relevant ones:
+
+"""
+    items = []
+    for e in entities:
+        content = e.get("content")
+        if not content:
+            continue
+        item = f"- **[{e.get('type', 'general')}]** {content}"
+        if e.get("rationale"):
+            item += f"\n  - _Rationale: {e['rationale']}_"
+        if e.get("trigger"):
+            item += f"\n  - _When: {e['trigger']}_"
+        items.append(item)
+
+    return header + "\n".join(items)
+
+
+def main():
+    # Read input from stdin (hook provides JSON with prompt)
+    try:
+        input_data = json.load(sys.stdin)
+        log("=== Input Data ===")
+        log(f"  Keys: {list(input_data.keys())}")
+        log(f"  Full content: {json.dumps(input_data, indent=2)}")
+        log("=== End Input Data ===")
+    except json.JSONDecodeError as e:
+        log(f"Failed to parse JSON input: {e}")
+        return
+
+    # Load all entities from directory
+    entities_dir = find_entities_dir()
+    log(f"Entities dir: {entities_dir}")
+
+    if not entities_dir:
+        log("No entities directory found")
+        return
+
+    entities = load_all_entities(entities_dir)
+    if not entities:
+        log("No entities found")
+        return
+
+    log(f"Loaded {len(entities)} entities")
+
+    # Output all entities - Claude will filter for relevance
+    output = format_entities(entities)
+    print(output)
+    log(f"Output {len(output)} chars to stdout")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/plugins/kaizen/skills/save-trajectory/SKILL.md b/platform-integrations/claude/plugins/kaizen-lite/skills/save-trajectory/SKILL.md
similarity index 100%
rename from plugins/kaizen/skills/save-trajectory/SKILL.md
rename to platform-integrations/claude/plugins/kaizen-lite/skills/save-trajectory/SKILL.md
diff --git a/plugins/kaizen/skills/save-trajectory/scripts/save_trajectory.py b/platform-integrations/claude/plugins/kaizen-lite/skills/save-trajectory/scripts/save_trajectory.py
similarity index 100%
rename from plugins/kaizen/skills/save-trajectory/scripts/save_trajectory.py
rename to platform-integrations/claude/plugins/kaizen-lite/skills/save-trajectory/scripts/save_trajectory.py
diff --git a/plugins/kaizen/skills/save/SKILL.md b/platform-integrations/claude/plugins/kaizen-lite/skills/save/SKILL.md
similarity index 100%
rename from plugins/kaizen/skills/save/SKILL.md
rename to platform-integrations/claude/plugins/kaizen-lite/skills/save/SKILL.md
diff --git a/roo-skills/.roomodes b/platform-integrations/roo/kaizen-lite/skills/.roomodes
similarity index 100%
rename from roo-skills/.roomodes
rename to platform-integrations/roo/kaizen-lite/skills/.roomodes
diff --git a/roo-skills/kaizen-learn/SKILL.md b/platform-integrations/roo/kaizen-lite/skills/kaizen-learn/SKILL.md
similarity index 100%
rename from roo-skills/kaizen-learn/SKILL.md
rename to platform-integrations/roo/kaizen-lite/skills/kaizen-learn/SKILL.md
diff --git a/roo-skills/kaizen-learn/scripts/save.py b/platform-integrations/roo/kaizen-lite/skills/kaizen-learn/scripts/save.py
similarity index 100%
rename from roo-skills/kaizen-learn/scripts/save.py
rename to platform-integrations/roo/kaizen-lite/skills/kaizen-learn/scripts/save.py
diff --git a/roo-skills/kaizen-recall/SKILL.md b/platform-integrations/roo/kaizen-lite/skills/kaizen-recall/SKILL.md
similarity index 100%
rename from roo-skills/kaizen-recall/SKILL.md
rename to platform-integrations/roo/kaizen-lite/skills/kaizen-recall/SKILL.md
diff --git a/roo-skills/kaizen-recall/scripts/get.py b/platform-integrations/roo/kaizen-lite/skills/kaizen-recall/scripts/get.py
similarity index 100%
rename from roo-skills/kaizen-recall/scripts/get.py
rename to platform-integrations/roo/kaizen-lite/skills/kaizen-recall/scripts/get.py