tylor-mcp 1.0.0 → 1.1.1

package/.npmrc.publish

@@ -0,0 +1 @@
+//registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}

package/README.md

@@ -1,146 +1,165 @@
-<div align="center">
-  <img src="assets/tylor_logo.png" alt="Tylor Logo" width="150">
-  <h1>Tylor</h1>
-  <p><strong>The Tailor to Your Threads</strong></p>
-  <p><em>Give Claude Code persistent memory, laser-focused context, and an autonomous team of specialists.</em></p>
-  
-  [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-  [![Platform: Windows | macOS | Linux | WSL](https://img.shields.io/badge/Platform-Cross--Platform-success)](#)
-  [![Claude Code](https://img.shields.io/badge/Integration-Claude_Code-orange)](#)
-  [![GitHub Copilot](https://img.shields.io/badge/Integration-GitHub_Copilot-blue)](#)
-  [![Antigravity](https://img.shields.io/badge/Integration-Antigravity-blueviolet)](#)
-</div>
-
----
-
-Tylor transforms your Claude Code experience from a single-shot terminal interaction into a **persistent, intelligent workspace**. 
-
-Every time you open Claude Code, you normally start from zero. Tylor fixes that. It organizes your work into **threads**—isolated, named workspaces that survive restarts and reboots. It remembers every decision, every line of code, and every discussion, so you never have to repeat yourself.
-
-**No database. No cloud account. No configuration. Just install and go.**
-
----
-
-## 🎨 How It Works
-
-<div align="center">
-  <img src="assets/tylor_threads_concept.png" alt="Tylor Threads Architecture" width="800">
-  <p><em>Tylor weaves parallel, persistent memory threads and orchestrates specialist sub-agents.</em></p>
-</div>
-
----
-
-## ✨ Features
-
-### 🧠 Persistent Memory
-Tylor completely eliminates the "context reset." Shut down your computer, close your terminal, and come back a week later—Claude will pick up exactly where you left off. 
-
-### 🗂️ Context Isolation (Threads)
-Work in parallel without context bleed. Discuss frontend components in a `Frontend` thread and database schemas in a `Backend` thread. By isolating context, token usage stays low, and Claude's focus stays incredibly sharp.
-
-### 🤖 Intelligent Orchestration 
-You don't need to micromanage. Claude acts as the orchestrator. If you ask it to review architecture, it will dynamically load its `cto` persona. If you ask it to write a PRD, it natively invokes the `bmad` skill framework to get the job done. 
-
-### 🔌 Infinite Extensibility (Lazy-Loading)
-Tylor is built on a production-hardened ADK-pattern harness. You can register hundreds of domain-specific ECC skills (like `ecc/web`, `ecc/data`) via the `/add-skill` command. Tylor **lazy-loads** only the tools required for the current prompt, giving you massive capability scaling without ever blowing up Claude's token context window.
-
-### 🏗️ Autonomous AFK Sandboxing
-Declare a sandbox for your thread and let Claude work autonomously. Assign large, complex tasks and let Claude execute them while you step away from the keyboard.
-
-### 📊 Visual Dashboard
-Monitor your entire workspace through a beautiful, locally hosted web UI. Track active threads, review past conversations, and watch autonomous agent progress in real-time.
-
----
-
-## 🚀 Installation
-
-Tylor installs seamlessly into your Claude Code, Claude Desktop, GitHub Copilot, Antigravity, or VSCode Claude extension environment. Requires Python 3.8+.
-
-### ⚡ Option 1: The One-Line Installer (Recommended)
-
-If you have Node.js installed, you can configure Tylor instantly across all your clients without manually cloning the repository. Simply run:
-
-```bash
-npx tylor-mcp
-```
-
-### 💻 Option 2: Manual Git Clone
-
-**macOS / Linux / WSL:**
-```bash
-git clone https://github.com/GunjanGrunge/tylor ~/.claude/plugins/GunjanGrunge/tylor
-python3 ~/.claude/plugins/GunjanGrunge/tylor/install.py
-```
-
-**Windows:**
-```powershell
-git clone https://github.com/GunjanGrunge/tylor %USERPROFILE%\.claude\plugins\GunjanGrunge\tylor
-python %USERPROFILE%\.claude\plugins\GunjanGrunge\tylor\install.py
-```
-
-### Step 3: Verify
-
-1. Restart your Claude, GitHub Copilot, or Antigravity client completely (close the terminal/app and reopen it).
-2. Type `/help-agent101` in your prompt (or use Copilot Chat / `/mcp show`).
-3. If you see the capability index, Tylor is fully operational!
-
----
-
-## 🕹️ Quick Start
-
-Creating your first persistent workflow is incredibly simple:
-
-```text
-/new-thread Authentication   ← Create a persistent workspace
-/run we need to implement JWT based authentication
-
-/new-thread Dashboard UI     ← Create an isolated UI thread
-/run build a react dashboard with a sidebar
-
-/switch-thread Authentication ← Instantly switch context back to Auth
-/run add refresh token logic
-
-/list-threads                ← View your workspace status
-/open-threads-ui             ← Launch the visual dashboard
-```
-
----
-
-## 🛠️ Command Reference
-
-Tylor exposes a suite of powerful commands directly within Claude:
-
-| Command | Description |
-|---|---|
-| `/new-thread <name>` | Create a named thread and seamlessly switch future work into it. |
-| `/switch-thread <name>` | Switch context to an existing thread (fuzzy matching supported). |
-| `/list-threads` | Show all available threads alongside their status and activity. |
-| `/kill-thread <name>` | Close a thread and dispatch asynchronous summarization. |
-| `/recall` | Search through the deep semantic memory of your active thread. |
-| `/add-skill` | Install a new skill package dynamically. |
-| `/open-threads-ui` | Open the live, local thread visualizer UI in your browser. |
-| `/set-sandbox <path>` | Declare specific filesystem roots for secure, autonomous execution. |
-| `/afk-status` | Get real-time progress reports on current autonomous background tasks. |
-
-> **Pro Tip:** You can also use shorthand aliases like `CT <name>` to create a thread or `SwThread <name>` to switch.
-
----
-
-## 🎭 Sub-Agents & Personas
-
-Tylor comes pre-equipped with specialist sub-agents. Claude will **automatically invoke** these personas based on the nature of your query—no manual intervention required.
-
-* **`cto`**: System architecture, tradeoffs, platform strategy, and engineering standards.
-* **`code_agent`**: Senior software engineer laser-focused on shipping robust code and tests.
-* **`analyst`**: Market research, data synthesis, and technical decision support.
-* **`ceo`**: Product strategy, roadmap prioritization, and stakeholder framing.
-
----
-
-## 📄 License
-
-This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
-
-<div align="center">
-  <p><em>Tylor — Tailoring the future of AI development.</em></p>
-</div>
+<div align="center">
+  <img src="assets/tylor_logo.png" alt="Tylor Logo" width="150">
+  <h1>Tylor</h1>
+  <p><strong>The Tailor to Your Threads</strong></p>
+  <p><em>Give Claude Code persistent memory, laser-focused context, and an autonomous team of specialists.</em></p>
+  
+  [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+  [![Platform: Windows | macOS | Linux | WSL](https://img.shields.io/badge/Platform-Cross--Platform-success)](#)
+  [![Claude Code](https://img.shields.io/badge/Integration-Claude_Code-orange)](#)
+  [![GitHub Copilot](https://img.shields.io/badge/Integration-GitHub_Copilot-blue)](#)
+  [![Antigravity](https://img.shields.io/badge/Integration-Antigravity-blueviolet)](#)
+</div>
+
+---
+
+Tylor transforms your Claude Code experience from a single-shot terminal interaction into a **persistent, intelligent workspace**. 
+
+Every time you open Claude Code, you normally start from zero. Tylor fixes that. It organizes your work into **threads**—isolated, named workspaces that survive restarts and reboots. It remembers every decision, every line of code, and every discussion, so you never have to repeat yourself.
+
+**No database. No cloud account. No configuration. Just install and go.**
+
+---
+
+## 🎨 How It Works
+
+<div align="center">
+  <img src="assets/tylor_threads_concept.png" alt="Tylor Threads Architecture" width="800">
+  <p><em>Tylor weaves parallel, persistent memory threads and orchestrates specialist sub-agents.</em></p>
+</div>
+
+---
+
+## ✨ Features
+
+### 🧠 Persistent Memory
+Tylor completely eliminates the "context reset." Shut down your computer, close your terminal, and come back a week later—Claude will pick up exactly where you left off. 
+
+### 🗂️ Context Isolation (Threads)
+Work in parallel without context bleed. Discuss frontend components in a `Frontend` thread and database schemas in a `Backend` thread. By isolating context, token usage stays low, and Claude's focus stays incredibly sharp.
+
+### 🤖 Intelligent Orchestration 
+You don't need to micromanage. Claude acts as the orchestrator. If you ask it to review architecture, it will dynamically load its `cto` persona. If you ask it to write a PRD, it natively invokes the `bmad` skill framework to get the job done. 
+
+### 🔌 Infinite Extensibility (Lazy-Loading)
+Tylor is built on a production-hardened ADK-pattern harness. You can register hundreds of domain-specific ECC skills (like `ecc/web`, `ecc/data`) via the `/add-skill` command. Tylor **lazy-loads** only the tools required for the current prompt, giving you massive capability scaling without ever blowing up Claude's token context window.
+
+### 🏗️ Autonomous AFK Sandboxing
+Declare a sandbox for your thread and let Claude work autonomously. Assign large, complex tasks and let Claude execute them while you step away from the keyboard.
+
+### 📊 Visual Dashboard
+Monitor your entire workspace through a beautiful, locally hosted web UI. Track active threads, review past conversations, and watch autonomous agent progress in real-time.
+
+---
+
+## 🚀 Installation
+
+Tylor installs seamlessly into your Claude Code, Claude Desktop, GitHub Copilot, Antigravity, or VSCode Claude extension environment. Requires Python 3.8+.
+
+### ⚡ Option 1: The One-Line Installer (Recommended)
+
+If you have Node.js installed, you can configure Tylor instantly across all your clients without manually cloning the repository. Simply run:
+
+```bash
+npx tylor-mcp
+```
+
+### 💻 Option 2: Manual Git Clone
+
+**macOS / Linux / WSL:**
+```bash
+git clone https://github.com/GunjanGrunge/tylor ~/.claude/plugins/GunjanGrunge/tylor
+python3 ~/.claude/plugins/GunjanGrunge/tylor/install.py
+```
+
+**Windows:**
+```powershell
+git clone https://github.com/GunjanGrunge/tylor %USERPROFILE%\.claude\plugins\GunjanGrunge\tylor
+python %USERPROFILE%\.claude\plugins\GunjanGrunge\tylor\install.py
+```
+
+### Step 3: Verify
+
+1. Restart your Claude, GitHub Copilot, or Antigravity client completely (close the terminal/app and reopen it).
+2. Type `/help-agent101` in your prompt (or use Copilot Chat / `/mcp show`).
+3. If you see the capability index, Tylor is fully operational!
+
+---
+
+## 🕹️ Quick Start
+
+Creating your first persistent workflow is incredibly simple:
+
+```text
+/new-thread Authentication   ← Create a persistent workspace
+/run we need to implement JWT based authentication
+
+/new-thread Dashboard UI     ← Create an isolated UI thread
+/run build a react dashboard with a sidebar
+
+/switch-thread Authentication ← Instantly switch context back to Auth
+/run add refresh token logic
+
+/list-threads                ← View your workspace status
+/open-threads-ui             ← Launch the visual dashboard
+```
+
+---
+
+## 🛠️ Command Reference
+
+Tylor exposes a suite of powerful commands directly within Claude:
+
+| Command | Description |
+|---|---|
+| `/new-thread <name>` | Create a named thread and seamlessly switch future work into it. |
+| `/switch-thread <name>` | Switch context to an existing thread (fuzzy matching supported). |
+| `/list-threads` | Show all available threads alongside their status and activity. |
+| `/kill-thread <name>` | Close a thread and dispatch asynchronous summarization. |
+| `/recall` | Search through the deep semantic memory of your active thread. |
+| `/add-skill` | Install a new skill package dynamically. |
+| `/open-threads-ui` | Open the live, local thread visualizer UI in your browser. |
+| `/set-sandbox <path>` | Declare specific filesystem roots for secure, autonomous execution. |
+| `/afk-status` | Get real-time progress reports on current autonomous background tasks. |
+
+> **Pro Tip:** You can also use shorthand aliases like `CT <name>` to create a thread or `SwThread <name>` to switch.
+
+---
+
+## 🔒 Bumblebee Security Gate
+
+Tylor now includes a default, plugin-wide security gate powered by Bumblebee. When a risky command is detected—especially package installs, extension installs, skill/package additions, or MCP config changes—Tylor will initiate a read-only Bumblebee scan before the command runs.
+
+- Enabled by default for any command pattern that looks like `pip install`, `npm install`, editor/extension installs, or skill/config setup.
+- If Bumblebee is missing, Tylor will flag the command and surface clear guidance instead of executing it blindly.
+- If Bumblebee detects risk, execution is blocked and the user sees actionable alternatives.
+
+Suggested responses from the gate include:
+
+- Install Bumblebee or set `BUMBLEBEE_PATH` if the CLI is not found.
+- Run `bumblebee scan --json` manually before retrying.
+- Disable the gate temporarily with `BUMBLEBEE_ENABLED=false` only if you understand the risk.
+- Review package metadata, MCP config changes, and AI tool integrations before proceeding.
+
+This layer applies across the plugin, regardless of which thread or persona is active.
+
+---
+
+## 🎭 Sub-Agents & Personas
+
+Tylor comes pre-equipped with specialist sub-agents. Claude will **automatically invoke** these personas based on the nature of your query—no manual intervention required.
+
+* **`cto`**: System architecture, tradeoffs, platform strategy, and engineering standards.
+* **`code_agent`**: Senior software engineer laser-focused on shipping robust code and tests.
+* **`analyst`**: Market research, data synthesis, and technical decision support.
+* **`ceo`**: Product strategy, roadmap prioritization, and stakeholder framing.
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+<div align="center">
+  <p><em>Tylor — Tailoring the future of AI development.</em></p>
+</div>

package/bin/tylor.js

@@ -1,7 +1,41 @@
 #!/usr/bin/env node
-const { spawnSync } = require('child_process');
+const { spawnSync, execSync } = require('child_process');
 const path = require('path');
+const https = require('https');
+const fs = require('fs');
 
+// ── Update check ──────────────────────────────────────────────────────────────
+function checkForUpdate() {
+    try {
+        const pkgPath = path.join(__dirname, '..', 'package.json');
+        const localPkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        const localVersion = localPkg.version;
+        const pkgName = localPkg.name;
+
+        const url = `https://registry.npmjs.org/${pkgName}/latest`;
+        const req = https.get(url, { timeout: 3000 }, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try {
+                    const latest = JSON.parse(data).version;
+                    if (latest && latest !== localVersion) {
+                        console.log('');
+                        console.log(`  ⚠️  Update available: ${localVersion} → ${latest}`);
+                        console.log(`  Run: npm update -g ${pkgName}  (or npx ${pkgName}@latest)`);
+                        console.log('');
+                    }
+                } catch (_) { /* silent */ }
+            });
+        });
+        req.on('error', () => { /* silent — offline or registry down */ });
+        req.on('timeout', () => { req.destroy(); });
+    } catch (_) { /* silent */ }
+}
+
+checkForUpdate();
+
+// ── Installer ─────────────────────────────────────────────────────────────────
 const installPy = path.join(__dirname, '..', 'install.py');
 const args = process.argv.slice(2);
 
@@ -13,7 +47,7 @@ let result = spawnSync('python', [installPy, ...args], { stdio: 'inherit' });
 // Fallback to `python3` if `python` fails (standard on macOS/Linux)
 if (result.error || result.status !== 0) {
     result = spawnSync('python3', [installPy, ...args], { stdio: 'inherit' });
-    
+
     if (result.error) {
         console.error("❌ Failed to launch the Tylor installer. Please ensure Python 3.8+ is installed on your system.");
         process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tylor-mcp",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Give Claude Code persistent memory, laser-focused context, and an autonomous team of specialists.",
   "main": "server/main.py",
   "bin": {
@@ -20,5 +20,8 @@
     "github-copilot"
   ],
   "author": "Gunjan Grunge",
-  "license": "MIT"
+  "license": "MIT",
+  "scripts": {
+    "dev:sync": "node scripts/dev-sync.js"
+  }
 }

package/pytest.ini

@@ -1,2 +1,2 @@
-[pytest]
-asyncio_mode = auto
+[pytest]
+asyncio_mode = auto

package/scripts/dev-sync.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+/**
+ * dev-sync.js — sync dev changes to the live installed server.
+ *
+ * Reads PYTHONPATH from ~/.claude/settings.json (written there by install.py),
+ * so it always targets the correct installed location regardless of npm version
+ * or _npx cache hash. No hardcoding.
+ *
+ * Usage:
+ *   npm run dev:sync
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ── Find the installed server path from settings.json ────────────────────────
+
+function findInstalledPath() {
+  const candidates = [
+    path.join(os.homedir(), '.claude', 'settings.json'),
+    path.join(os.homedir(), 'AppData', 'Roaming', 'Claude', 'settings.json'),
+  ];
+
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    try {
+      const settings = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+      const pythonpath =
+        settings?.mcpServers?.agent101?.env?.PYTHONPATH;
+      if (pythonpath && fs.existsSync(pythonpath)) {
+        return pythonpath;
+      }
+    } catch (_) { /* malformed — skip */ }
+  }
+  return null;
+}
+
+// ── Files and directories to sync ────────────────────────────────────────────
+
+const DEV_ROOT = path.join(__dirname, '..');
+
+const SYNC_FILES = [
+  'server/tools/harness.py',
+  'server/tools/security.py',
+  'server/tools/executor.py',
+  'server/tools/registry.py',
+];
+
+const SYNC_DIRS = [
+  'skills',
+];
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function copyFile(src, dst) {
+  fs.mkdirSync(path.dirname(dst), { recursive: true });
+  fs.copyFileSync(src, dst);
+}
+
+function syncDir(srcDir, dstDir) {
+  if (!fs.existsSync(srcDir)) return 0;
+  let count = 0;
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path.join(srcDir, entry.name);
+    const dstPath = path.join(dstDir, entry.name);
+    if (entry.isDirectory()) {
+      count += syncDir(srcPath, dstPath);
+    } else {
+      copyFile(srcPath, dstPath);
+      count++;
+    }
+  }
+  return count;
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+const installed = findInstalledPath();
+
+if (!installed) {
+  console.error('❌  Could not find installed server path in ~/.claude/settings.json');
+  console.error('    Run: npx tylor-mcp  to install first.');
+  process.exit(1);
+}
+
+console.log(`🎯  Target: ${installed}\n`);
+
+let total = 0;
+
+for (const rel of SYNC_FILES) {
+  const src = path.join(DEV_ROOT, rel);
+  const dst = path.join(installed, rel);
+  if (!fs.existsSync(src)) {
+    console.warn(`⚠️   skip (not found): ${rel}`);
+    continue;
+  }
+  copyFile(src, dst);
+  console.log(`  ✓  ${rel}`);
+  total++;
+}
+
+for (const rel of SYNC_DIRS) {
+  const src = path.join(DEV_ROOT, rel);
+  const dst = path.join(installed, rel);
+  const n = syncDir(src, dst);
+  if (n > 0) {
+    console.log(`  ✓  ${rel}/ (${n} files)`);
+    total += n;
+  }
+}
+
+console.log(`\n✅  ${total} file(s) synced. Restart Claude Code to pick up changes.`);

package/server/config.py

@@ -1,8 +1,8 @@
 """
 server/config.py — Agent101 server configuration.
-Reads AWS profile, Bedrock region, and Platform on AWS key.
+Reads local storage settings and optional cloud provider settings.
 Resolution order: env var → ~/.agent101/config.json → .env file → defaults.
-Warns on missing optional config; never crashes on startup.
+Missing cloud settings are normal in local-first mode; startup never crashes.
 """
 from __future__ import annotations
 import json
@@ -57,6 +57,7 @@ def _load() -> dict:
     cfg = {
         "aws_profile":       _get("AWS_PROFILE"),
         "aws_access_key_id": _get("AWS_ACCESS_KEY_ID"),
+        "storage_mode": _get("AGENT101_STORAGE_MODE", default="local"),
         "bedrock_region": _get("BEDROCK_REGION", default="us-east-1"),
         "bedrock_opus_model": _get(
             "BEDROCK_OPUS_MODEL",
@@ -69,19 +70,13 @@ def _load() -> dict:
         "s3_bucket":      _get("S3_BUCKET"),
         "opensearch_host": _get("OPENSEARCH_HOST"),
         "opensearch_port": _get("OPENSEARCH_PORT", default="9200"),
+        "bumblebee_enabled": str(_get("BUMBLEBEE_ENABLED", default="true")).strip().lower() in {"1", "true", "yes", "on"},
+        "bumblebee_path": _get("BUMBLEBEE_PATH"),
     }
 
-    # Warn on optional keys that affect runtime features
-    if not cfg["platform_key"]:
-        logger.warning(
-            "ANTHROPIC_PLATFORM_AWS_API_KEY/ANTHROPIC_AWS_API_KEY not set — "
-            "token overflow fallback to Claude Platform on AWS is disabled"
-        )
-    if not cfg["opensearch_host"]:
-        logger.warning(
-            "OPENSEARCH_HOST not set — "
-            "semantic memory recall (recall_memory) will be unavailable until configured"
-        )
+    if cfg["storage_mode"] not in {"local", "aws"}:
+        logger.warning("Unknown AGENT101_STORAGE_MODE=%s; falling back to local mode", cfg["storage_mode"])
+        cfg["storage_mode"] = "local"
 
     return cfg
 

package/server/storage/dynamo.py

@@ -187,6 +187,29 @@ class DynamoClient:
             attributes["Task"] = task
         return self.put_item(sk=sk, attributes=attributes)
 
+    def put_agent_event(
+        self,
+        thread_id: str,
+        agent_id: str,
+        event_type: str,
+        content: str,
+        persona: str | None = None,
+    ) -> dict:
+        """Persist a streamed sub-agent event for live UI replay."""
+        self._validate_agent_id(agent_id)
+        sk = f"THREAD#{thread_id}#AGENT#{agent_id}#EVENT#{_unique_event_suffix()}"
+        self._assert_thread_isolation(thread_id, sk)
+        attributes = {
+            "ThreadId": thread_id,
+            "AgentId": agent_id,
+            "Type": "agent_event",
+            "EventType": event_type,
+            "Content": content,
+        }
+        if persona:
+            attributes["Persona"] = persona
+        return self.put_item(sk=sk, attributes=attributes)
+
     def put_agent_handoff(
         self,
         thread_id: str,
@@ -230,6 +253,16 @@ class DynamoClient:
         items = self.query_thread(thread_id, f"THREAD#{thread_id}#AGENT#")
         return [item for item in items if item.get("SK", "").endswith("#STATE")]
 
+    def query_agent_events(self, thread_id: str, agent_id: str | None = None) -> list:
+        """Return streamed sub-agent events for one thread, optionally one agent."""
+        prefix = f"THREAD#{thread_id}#AGENT#"
+        if agent_id:
+            self._validate_agent_id(agent_id)
+            prefix = f"{prefix}{agent_id}#EVENT#"
+        items = self.query_thread(thread_id, prefix)
+        events = [item for item in items if "#EVENT#" in item.get("SK", "")]
+        return sorted(events, key=lambda item: item.get("SK", ""))
+
     def get_thread_meta(self, thread_id: str) -> dict | None:
         """Return thread META item for the given thread_id."""
         return self.get_item(thread_id, f"THREAD#{thread_id}#META")