tylor-mcp 1.0.0

package/.aws-setup.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# Claude Platform on AWS Setup for agent101
+
+# AWS Credentials Configuration
+# Using existing credentials in ~/.aws/credentials
+export AWS_PROFILE=default
+export AWS_REGION=us-east-1
+
+# Claude Platform on AWS Configuration
+export CLAUDE_CODE_USE_ANTHROPIC_AWS=1
+export ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01C19h6yMnj1V4X6Uo3VUrjj
+export ANTHROPIC_AWS_BASE_URL=https://aws-external-anthropic.us-east-1.api.aws
+
+# Model versions (optional - uses latest if not set)
+# export ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-7
+# export ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-6
+# export ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5
+
+# Refresh credentials if they expire
+export AWS_AUTH_REFRESH="aws sso login --profile ${AWS_PROFILE}"
+
+echo "✓ Claude Platform on AWS environment configured"
+echo "  Workspace ID: $ANTHROPIC_AWS_WORKSPACE_ID"
+echo "  Region: $AWS_REGION"
+echo "  Auth method: AWS credentials (SigV4)"

package/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "tylor",
+  "version": "0.1.0",
+  "description": "Tylor — the tailor to your threads. Eliminates Claude session death with persistent named threads, silent code indexing, a live thread visualizer, agent personas, and AFK autonomous execution.",
+  "author": {
+    "name": "GunjanGrunge"
+  },
+  "repository": "https://github.com/GunjanGrunge/tylor",
+  "license": "MIT",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "mcp",
+    "plugin",
+    "threads",
+    "memory",
+    "persistence",
+    "agents",
+    "session"
+  ],
+  "homepage": "https://github.com/GunjanGrunge/tylor#readme"
+}

package/.mcp.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "agent101": {
+      "type": "stdio",
+      "command": "sh",
+      "args": [
+        "-c",
+        "_P=\"${CLAUDE_PLUGIN_ROOT:-}\"; if [ -z \"$_P\" ]; then for _D in \"$HOME/.claude/plugins/GunjanGrunge/tylor\" \"$HOME/.claude/plugins/cache/GunjanGrunge/tylor/\"[0-9]*/ \"$HOME/.claude/plugins/cache/gunjangrunge/tylor/\"[0-9]*/; do [ -f \"$_D/server/main.py\" ] && { _P=\"$_D\"; break; }; done; fi; [ -n \"$_P\" ] || { echo 'Tylor: plugin root not found' >&2; exit 1; }; _VENV=\"$HOME/.tylor/venv\"; if [ ! -f \"$_VENV/bin/python3\" ] && [ ! -f \"$_VENV/Scripts/python3.exe\" ] && [ ! -f \"$_VENV/Scripts/python.exe\" ]; then python3 -m venv \"$_VENV\" && \"$_VENV/bin/pip\" install -q -r \"$_P/server/requirements.txt\" 2>&1 | tail -2; fi; _PY=\"$_VENV/bin/python3\"; [ -f \"$_PY\" ] || _PY=\"$_VENV/Scripts/python3.exe\"; [ -f \"$_PY\" ] || _PY=\"$_VENV/Scripts/python.exe\"; cd \"$_P\" && exec \"$_PY\" -m server.main"
+      ]
+    }
+  }
+}

package/AGENTS.md

@@ -0,0 +1,93 @@
+<claude-mem-context>
+# Memory Context
+
+# [agent101] recent context, 2026-05-13 8:41pm GMT+5:30
+
+Legend: 🎯session 🔴bugfix 🟣feature 🔄refactor ✅change 🔵discovery ⚖️decision 🚨security_alert 🔐security_note
+Format: ID TIME TYPE TITLE
+Fetch details: get_observations([IDs]) | Search: mem-search skill
+
+Stats: 50 obs (17,754t read) | 464,852t work | 96% savings
+
+### May 12, 2026
+S72 Run BMAD Implementation Readiness Check for agent101 project (May 12 at 5:08 PM)
+S73 BMAD Implementation Readiness Check — Epic Coverage Validation Results for agent101 (May 12 at 5:12 PM)
+S74 Execute /bmad-create-architecture command to design and validate complete system architecture for agent101 project with 100% feature requirement coverage. (May 12 at 5:16 PM)
+S75 Story 2.6 model router 3-tier fallback → Story 2.7 kill_thread async Bedrock Opus summarizer implementation (May 12 at 5:25 PM)
+251 10:02p ✅ sprint-status.yaml updated: story 2-7 moved from in-progress to review
+S76 Story 2.8 implementation — Claude Code lifecycle hooks (SessionStart, Stop, PostToolUse) for agent101 thread management plugin (May 12 at 10:02 PM)
+252 10:33p 🔵 Thread Management Epic Stories 2.9 & 2.10 Reviewed
+253 " 🔵 agent101 install.sh Full Implementation Reviewed
+254 10:34p 🟣 Story 2.8 Implementation Artifact Created
+255 " ✅ Story 2.8 Sprint Status Advanced from Backlog to In-Progress
+256 " 🟣 Story 2.8 Hook Tests Written (TDD)
+257 10:35p 🔵 Story 2.8 Tests Confirmed Red — Implementation Files Not Yet Created
+258 " 🟣 server/tools/hooks.py Implemented
+259 10:36p 🟣 Three Claude Code Hook Shell Scripts Created
+260 " 🟣 Story 2.8 Hook Tests All Green — Implementation Complete
+261 " 🔵 Hook Shell Scripts Pass Syntax Check; Full Regression Suite Running Clean
+262 " 🟣 Full Regression Suite Passes — 163/163 Tests Green
+263 10:37p 🟣 Story 2.8 Complete — All Tasks Done, Status Advanced to Review
+264 " ✅ Sprint Status Updated — Story 2.8 Marked Review
+S77 Story 2.9: Thread Management Slash Commands — implement 5 SKILL.md files for /new-thread, /switch-thread, /kill-thread, /list-threads, /recall (May 12 at 10:37 PM)
+265 10:43p 🔵 Thread Management Skill Specs in epics.md
+266 " 🔵 agent101 BMAD Skill Library Structure
+267 " 🔵 agent101 Architecture: Two-Tier MCP Tool System with Sprint Status
+268 10:44p ✅ Story 2.9 Implementation Artifact Created, Sprint Status Set to In-Progress
+269 " 🟣 Test Suite Created for Story 2.9 Thread Command Skill Files
+270 " 🔵 TDD Red Phase Confirmed: All 5 Thread Command SKILL.md Files Missing
+271 10:45p 🟣 All 5 Thread Management SKILL.md Files Created
+272 " 🔴 One Test Failing: Case-Sensitivity Mismatch on "recovery" Phrase Check
+273 " 🔴 All 5 Story 2.9 Tests Pass: "recovery" Phrase Added to All SKILL.md Error Sections
+274 " 🟣 Full Regression Suite Green: 56 Tests Pass After Story 2.9
+275 " 🟣 Story 2.9 Complete: Full Server Test Suite 168/168 Passing
+276 10:46p ✅ Story 2.9 Moved to Review Status with Full Completion Record
+277 " ✅ Sprint Status YAML Confirmed: Story 2.9 at "review"
+S78 Code review of Story 2.9: Thread Management Slash Commands using bmad-code-review skill (May 12 at 10:47 PM)
+278 10:56p 🔵 bmad-code-review Skill Architecture Revealed
+279 " 🔵 bmad-code-review Workflow Config: Minimal Customization Active
+280 " 🔵 bmad-code-review Step-01: 5-Tier Review Target Resolution Cascade
+281 10:57p 🟣 Story 2.9: Thread Management Slash Commands Implemented
+282 " 🔵 agent101 Architecture: WebSocket UI, Lifecycle Hooks, and Thread Visualizer
+283 " 🔵 /recall Skill Depends on OpenSearch and Bedrock for Semantic Memory
+284 " 🔵 bmad-code-review Step-02: Parallel Adversarial Review Layer Architecture
+S79 Code review of Story 2.9 (Thread Management Slash Commands) — one bug found and fixed (May 12 at 10:58 PM)
+285 11:00p 🔴 Fixed /kill-thread Misleading Confirmation Wording
+286 " 🔴 kill-thread Fix Verified: 5/5 Tests Pass After Wording Change
+S80 Implementation and completion of Story 2.10 (Fuzzy Thread Name Matching) following Story 2.9 code review (May 12 at 11:00 PM)
+287 11:01p 🔵 Story 2.10: Fuzzy Thread Name Matching — Next Sprint Story
+288 " 🔵 tylor.py MCP Tool Implementations and Story 2.10 Gap Confirmed
+289 11:02p ✅ Story 2.10 Implementation Artifact Created, Sprint Status Set to In-Progress
+290 " 🟣 Story 2.10: Thread Resolver Tests Written (TDD RED Phase)
+291 11:03p 🔵 Story 2.10 TDD RED Confirmed: 5 Failures, MCP Error Code Verified
+292 " 🟣 server/tools/thread_resolver.py Implemented
+293 " 🟣 switch_thread_by_name MCP Tool Wired into tylor.py
+294 " 🟣 Story 2.10 TDD GREEN: All 5 Resolver Tests Pass
+295 11:04p ✅ test_tier1_schema.py Updated to Include switch_thread_by_name
+296 " ✅ skills/switch-thread/SKILL.md Updated for Fuzzy Query Flow
+297 " 🟣 Story 2.10 Complete: Full Regression Suite Passes at 174 Tests
+298 11:05p ✅ Story 2.10 Implementation Artifact Finalized, Status Set to Review
+### May 13, 2026
+299 10:46a 🟣 Story 4.1 ECC Tool Modules — Artifact Created and RED Tests Written
+300 " 🔵 agent101 Project Sprint Status Snapshot
+S81 Continue with next story — Story 4.1: ECC Tool Modules Initial 5 Categories (Epic 4, agent101 project) (May 13 at 10:48 AM)
+**Investigated**: Sprint status YAML and backlog to determine next story; Story 4.1 acceptance criteria for ECC lazy-loadable tool categories; existing registry.py stub; FastMCP tool registration patterns; McpError/INVALID_PARAMS error handling conventions already used in the codebase.
+
+**Learned**: - ECC tool categories (ecc/web, ecc/data, ecc/presentation, ecc/diagrams, ecc/pipeline) are implemented as importlib-loaded Python modules under server/tools/ecc/, each registering tools via @mcp.tool() on the shared mcp singleton.
+    - load_skill_tools() validates category keys against ECC_GROUPS dict, raises McpError(ErrorData(INVALID_PARAMS, ...)) for unknown groups, then calls importlib.import_module() and returns {tool_group, status: "loaded", tools: sorted(list)}.
+    - list_registry() remains a ToolError stub, deferred to Story 4.2.
+    - sprint-status.yaml reads were showing a cached "backlog" value (Chunk ID: 1376f9) even after successful patches — a tool-level read cache artifact; actual disk file was correctly updated.
+
+**Completed**: - Created story artifact: _bmad-output/implementation-artifacts/4-1-ecc-tool-modules-initial-5-categories.md
+    - Updated sprint-status.yaml: epic-4 and 4-1-ecc-tool-modules-initial-5-categories both moved from backlog → in-progress → review
+    - Created server/tools/ecc/__init__.py, web.py, data.py, presentation.py, diagrams.py, pipeline.py with lightweight MCP-registered tool stubs
+    - Updated server/tools/registry.py: replaced ToolError stub with real ECC_GROUPS dispatch + importlib loading
+    - Created server/tools/tests/test_ecc_tools.py: 6 tests (5 parametrized group loads + 1 unknown category error)
+    - TDD RED→GREEN complete: all 6 ECC tests pass; full suite 201/201 pass
+    - Story artifact updated with completion notes, file list, dev log, all tasks checked, status set to review
+
+**Next Steps**: Story 4.1 is fully complete and in review. Next story is Story 4.2: Two-Tier Tool Manifest and Skill Registry Client — implementing list_registry() with registry.json reading and expanding load_skill_tools() for external skill groups beyond the hardcoded ECC_GROUPS.
+
+
+Access 465k tokens of past work via get_observations([IDs]) or mem-search skill.
+</claude-mem-context>

package/CLAUDE.md

@@ -0,0 +1,99 @@
+# agent101 — Claude Code Plugin (TYLOR Thread Manager)
+
+## Project Overview
+
+agent101 is a Claude Code plugin — Personal Cognitive Infrastructure — that eliminates session death by giving Claude persistent, isolated, named context scopes called **threads**. Built as a FastMCP Python server with a local Thread Visualizer UI.
+
+## Architecture
+
+```
+Claude Code (terminal)
+  └── FastMCP server (server/main.py, stdio transport)
+        ├── Tier 1 tools: new_thread, switch_thread, kill_thread, list_threads, recall_memory
+        ├── Tier 2 tools (lazy): ECC skill modules (ecc/*/tools.py)
+        ├── aiohttp UI server (localhost:8765) — Thread Visualizer
+        └── Storage: DynamoDB single-table (Personal) or local JSON (Project mode)
+
+Claude Code hooks (hooks/)
+  ├── session-start.sh    → surfaces active thread context on session open
+  ├── session-checkpoint.sh → checkpoints thread state on Stop
+  └── kill-thread-trigger.sh → dispatches Bedrock Opus summarization on KillThread
+
+Thread Visualizer (ui/)
+  └── D3.js force graph, glassmorphism bubbles, silk SVG bezier curves, Vanta.js bg
+```
+
+## Directory Structure
+
+```
+agent101/
+├── server/                    # FastMCP Python server
+│   ├── main.py                # Entry point — co-starts FastMCP + aiohttp
+│   ├── config.py              # pydantic-settings (reads .env)
+│   ├── ui_server.py           # aiohttp web server (localhost:8765)
+│   ├── tools/                 # MCP tool modules
+│   │   ├── tylor.py           # Thread lifecycle tools (new/switch/kill/recall/list)
+│   │   ├── ui.py              # open_threads_ui tool
+│   │   ├── agents.py          # spawn_agent, list_personas
+│   │   ├── registry.py        # load_skill_tools, list_registry
+│   │   ├── executor.py        # sandboxed bash execution
+│   │   └── router.py          # 3-tier model router
+│   ├── storage/               # Storage clients
+│   │   ├── dynamo.py          # DynamoDB single-table client
+│   │   ├── json_store.py      # Project JSON mode (zero-infra)
+│   │   ├── s3.py              # S3 blob storage (>400KB)
+│   │   └── opensearch.py      # Vector search (Titan Embeddings v2)
+│   └── personas/              # Agent persona definitions
+├── ui/                        # Thread Visualizer (served by aiohttp)
+│   └── index.html             # D3.js force graph + WebSocket client
+├── hooks/                     # Claude Code lifecycle hook scripts
+├── skills/                    # Claude Code slash commands
+│   ├── new-thread/
+│   ├── switch-thread/
+│   ├── kill-thread/
+│   ├── list-threads/
+│   ├── recall/
+│   ├── add-skill/
+│   └── help-agent101/
+├── ecc/                       # ECC tool modules (lazy-loaded Tier 2)
+│   ├── web/, data/, presentation/, diagrams/, pipeline/
+├── install.sh                 # One-command install
+├── registry.json              # Installed skill index
+└── pytest.ini                 # Test config (asyncio_mode = auto)
+```
+
+## Starting the Server
+
+```bash
+cd server
+python3 -m venv .venv && source .venv/bin/activate
+pip install -r requirements.txt
+python3 -m server.main    # starts FastMCP on stdio + aiohttp on :8765
+```
+
+## Environment Setup
+
+Copy `.env` to `server/.env`. Required keys:
+- `AWS_REGION`, `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`
+- `DYNAMO_TABLE` (default: agent101)
+- `OPENSEARCH_HOST`, `OPENSEARCH_PORT`
+- `BEDROCK_REGION` (default: us-east-1)
+
+## Storage Modes
+
+- **Project mode** (default): threads stored at `{cwd}/.agent101/threads.json` — zero AWS required
+- **Personal mode**: DynamoDB-backed, cross-project, cross-machine
+
+## Key Conventions
+
+- All MCP tools use explicit `thread_id` parameter — never hidden server-side state
+- All errors raised as `McpError` — never return error dicts
+- DynamoDB items include mandatory fields: `PK`, `SK`, `CreatedAt`, `UpdatedAt`, `Version`
+- MCP tool names: `verb_noun` snake_case — immutable once registered
+- Status colors in UI: cyan=active, amber=awaiting, purple=running, dim=idle
+
+## Running Tests
+
+```bash
+python3 -m pytest server/tests/ -v
+```

package/CLAUDE_PLATFORM_AWS_SETUP.md

@@ -0,0 +1,105 @@
+# Claude Platform on AWS Setup Guide
+
+You've successfully configured agent101 to use Claude Platform on AWS. Here's what was set up:
+
+## ✓ Completed Setup
+
+### 1. AWS Credentials
+- **Status**: Active ✓
+- **Profile**: `default` (from `~/.aws/credentials`)
+- **User**: `bedrock_agent` in account `751289209169`
+- **Region**: `us-east-1`
+
+### 2. Environment Variables Configured
+
+Added to `server/.env`:
+```bash
+CLAUDE_CODE_USE_ANTHROPIC_AWS=1
+ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01C19h6yMnj1V4X6Uo3VUrjj
+ANTHROPIC_AWS_BASE_URL=https://aws-external-anthropic.us-east-1.api.aws
+AWS_PROFILE=default
+AWS_REGION=us-east-1
+```
+
+### 3. Authentication Method
+- **Type**: AWS SigV4 (recommended for teams)
+- **Credentials location**: `~/.aws/credentials`
+- **Workspace**: `wrkspc_01C19h6yMnj1V4X6Uo3VUrjj`
+
+## 🚀 Next Steps
+
+### Option A: Run Claude Code CLI with AWS
+
+```bash
+# 1. Source the setup script
+source .aws-setup.sh
+
+# 2. Verify Claude Code can see AWS
+code /status
+
+# 3. Start your project
+code "your question here"
+```
+
+### Option B: Run agent101 FastMCP Server
+
+```bash
+# 1. Navigate to server directory
+cd server
+
+# 2. Load AWS environment
+source ../.aws-setup.sh
+
+# 3. Install dependencies (if not already done)
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+
+# 4. Start the FastMCP server
+python3 -m server.main
+```
+
+### Option C: Use Agent SDK
+
+Your FastMCP server can now use Claude Platform on AWS by reading these environment variables:
+
+```python
+import os
+from anthropic import Anthropic
+
+# These are automatically read from .env
+client = Anthropic(
+    api_key=os.getenv("ANTHROPIC_AWS_API_KEY") or None,  # Falls back to AWS SigV4
+    base_url="https://aws-external-anthropic.us-east-1.api.aws"
+)
+```
+
+## 📋 Troubleshooting
+
+### If you see "403 Forbidden" or "AccessDenied"
+- Check IAM permissions for your user in AWS Console
+- Verify role has `aws-external-anthropic:InvokeModel` permission
+- Check that workspace ID is correct
+
+### If Claude Code is still hitting `api.anthropic.com`
+- Verify `CLAUDE_CODE_USE_ANTHROPIC_AWS=1` is set (not 0 or blank)
+- Check that `CLAUDE_CODE_USE_BEDROCK` and `CLAUDE_CODE_USE_FOUNDRY` are not set
+- Run `code /status` to confirm resolved provider
+
+### If credentials expire
+- Re-run the setup script or manually re-export variables
+- Credentials from `~/.aws/credentials` should work without refresh needed
+
+## 📚 Additional Resources
+
+- [Claude Platform on AWS docs](https://platform.claude.com/docs/en/build-with-claude/claude-platform-on-aws)
+- [IAM action reference](https://platform.claude.com/docs/en/api/claude-platform-on-aws-iam-actions)
+- [Claude models overview](https://platform.claude.com/docs/en/about-claude/models/overview)
+- [Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)
+
+## 🔐 Security Notes
+
+- Your API key is in `server/.env` (Git ignored)
+- AWS credentials come from `~/.aws/credentials`
+- Keep workspace ID confidential
+- Rotate API keys periodically if using that method instead of SigV4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gunjan Sarkar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+<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>

package/bin/tylor.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const installPy = path.join(__dirname, '..', 'install.py');
+const args = process.argv.slice(2);
+
+console.log("👔 Running Tylor Installer...");
+
+// Try `python` first (standard on Windows and some Unix systems)
+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);
+    }
+}
+
+process.exit(result.status);

package/hooks/kill-thread-trigger.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PLUGIN_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$PLUGIN_DIR"
+
+exec python3 -m server.tools.hooks kill-thread-trigger "$@"

package/hooks/post-tool-use-code-index.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PLUGIN_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$PLUGIN_DIR"
+
+exec python3 -m server.tools.hooks post-tool-use-code-index

package/hooks/session-checkpoint.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PLUGIN_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$PLUGIN_DIR"
+
+exec python3 -m server.tools.hooks session-checkpoint

package/hooks/session-start.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PLUGIN_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$PLUGIN_DIR"
+
+exec python3 -m server.tools.hooks session-start