ta-studio-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 TA Studios
+
+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,136 @@
+# ta-studio-mcp
+
+**Domain knowledge MCP server for AI agents working on mobile test automation.**
+
+One command gives your agent structured knowledge about OAVR navigation patterns, SoM screenshot annotation, coordinate scaling fixes, agent configuration, and 9+ documented bug fixes — so it builds on proven solutions instead of rediscovering them.
+
+## Quick Start
+
+```bash
+npx ta-studio-mcp
+```
+
+## What's Inside
+
+| Tool | What It Returns |
+|------|----------------|
+| `getMethodology` | 10+ topics: OAVR pattern, SoM annotation, coordinate scaling, agent config, vision click, mobile MCP, flicker detection, closed loop, device auto-select |
+| `getKnownIssues` | 9 documented bugs with symptoms, root causes, fixes, file paths, and commit SHAs |
+| `getCodebaseMap` | Full codebase structure — backend, frontend, agents, scripts, integrations, config |
+| `getWorkflow` | 7 step-by-step workflows: bug_fix, navigation_test, bbox_verify, agent_debug, feature, figma_analysis, flicker_test |
+| `getQuickCommands` | All dev commands for backend, frontend, E2E, device, and git |
+| `getConventions` | Code style guidelines, patterns, and 7 critical rules |
+| `getAgentConfig` | Agent configuration reference — models, parallel_tool_calls, reasoning, streaming |
+
+## Installation
+
+### Claude Code
+
+```bash
+claude mcp add ta-studio -- npx -y ta-studio-mcp
+```
+
+### Cursor
+
+Add to `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "ta-studio": {
+      "command": "npx",
+      "args": ["-y", "ta-studio-mcp"]
+    }
+  }
+}
+```
+
+### Windsurf
+
+Add to `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "ta-studio": {
+      "command": "npx",
+      "args": ["-y", "ta-studio-mcp"]
+    }
+  }
+}
+```
+
+### VS Code (Copilot / Continue / Augment)
+
+Add to `.vscode/settings.json`:
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "ta-studio": {
+        "command": "npx",
+        "args": ["-y", "ta-studio-mcp"]
+      }
+    }
+  }
+}
+```
+
+## Example Usage
+
+Ask your AI agent:
+
+- *"How does the OAVR pattern work?"* → Agent calls `getMethodology({ topic: "oavr" })`
+- *"What's the bounding box coordinate bug?"* → Agent calls `getKnownIssues({ category: "bbox_alignment" })`
+- *"How do I debug a navigation test?"* → Agent calls `getWorkflow({ name: "agent_debug" })`
+- *"What model does the coordinator use?"* → Agent calls `getAgentConfig()`
+
+## Key Knowledge Areas
+
+### Coordinate Scaling (Critical Fix)
+
+Mobile MCP screenshots are JPEG-compressed at ~45% of native resolution (486×1080 vs 1080×2400), but element coordinates from `list_elements_on_screen` are in native space. The fix:
+
+```
+scale_x = img.width / screen_width   → 486/1080 = 0.45
+scale_y = img.height / screen_height  → 1080/2400 = 0.45
+```
+
+### OAVR Navigation Pattern
+
+```
+Observe  → Screen Classifier analyzes current screen
+Act      → Execute action (click, swipe, type) via Mobile MCP
+Verify   → Action Verifier confirms success
+Reason   → Failure Diagnosis suggests recovery if failed
+```
+
+### Agent Configuration
+
+| Agent | Model | parallel_tool_calls | Reasoning |
+|-------|-------|-------------------|-----------|
+| Coordinator | gpt-5.2 | `true` | high |
+| Device Testing | gpt-5-mini | `false` | medium |
+
+## Tech Stack
+
+- **Runtime**: Node.js ≥ 18
+- **Protocol**: Model Context Protocol (MCP) via `@modelcontextprotocol/sdk`
+- **Transport**: stdio (local process)
+- **Schema**: Zod validation
+
+## Development
+
+```bash
+cd packages/ta-studio-mcp
+npm install
+npm run build    # Compile TypeScript
+npm run dev      # Watch mode
+npm start        # Run server
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE)
+

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+/**
+ * TA Studio MCP Server
+ *
+ * Domain knowledge, patterns, bug fixes, and workflows for AI agents
+ * working on the TA Studio mobile test automation platform.
+ *
+ * Usage:
+ *   npx ta-studio-mcp
+ *   claude mcp add ta-studio -- npx -y ta-studio-mcp
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerAllTools } from './tools/register-all.js';
+const server = new McpServer({
+    name: 'ta-studio-mcp',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        logging: {},
+    },
+});
+// Register all domain knowledge tools
+registerAllTools(server);
+// Connect via stdio transport (for local process-spawned integrations)
+const transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;;;;;;;GASG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D,MAAM,MAAM,GAAG,IAAI,SAAS,CAC1B;IACE,IAAI,EAAE,eAAe;IACrB,OAAO,EAAE,OAAO;CACjB,EACD;IACE,YAAY,EAAE;QACZ,OAAO,EAAE,EAAE;KACZ;CACF,CACF,CAAC;AAEF,sCAAsC;AACtC,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAEzB,uEAAuE;AACvE,MAAM,SAAS,GAAG,IAAI,oBAAoB,EAAE,CAAC;AAC7C,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC"}

package/dist/knowledge/codebase-map.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Codebase map — file purposes and architecture.
+ */
+export declare const CODEBASE_SECTIONS: Record<string, string>;
+export declare const CODEBASE_SECTION_LIST: string[];
+//# sourceMappingURL=codebase-map.d.ts.map

package/dist/knowledge/codebase-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codebase-map.d.ts","sourceRoot":"","sources":["../../src/knowledge/codebase-map.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAiHpD,CAAC;AAEF,eAAO,MAAM,qBAAqB,UAAiC,CAAC"}

package/dist/knowledge/codebase-map.js

@@ -0,0 +1,113 @@
+/**
+ * Codebase map — file purposes and architecture.
+ */
+export const CODEBASE_SECTIONS = {
+    overview: `# TA Studio Codebase Map
+
+Sections: backend, frontend, agents, scripts, integrations, config
+
+## Directory Structure
+my-fullstack-app/
+├── backend/app/          # FastAPI backend (Python 3.11+)
+├── frontend/test-studio/ # React + TypeScript + Vite frontend
+├── integrations/chef/    # Chef AI agent integration (Remix)
+├── packages/             # Local npm packages (ta-studio-mcp)
+├── scripts/              # Utility scripts
+├── tests/                # E2E and manual tests
+└── screenshots/          # Agent screenshots output`,
+    backend: `# Backend (backend/app/)
+
+| Path | Purpose |
+|------|---------|
+| main.py | FastAPI entry point, route registration |
+| agents/coordinator/ | Coordinator Agent (GPT-5.2) — orchestration |
+| agents/coordinator/coordinator_agent.py | Agent definition + handoffs |
+| agents/coordinator/coordinator_service.py | Main orchestration service |
+| agents/device_testing/ | Device Testing Agent (GPT-5-mini) |
+| agents/device_testing/device_testing_agent.py | Agent config (parallel_tool_calls=False) |
+| agents/device_testing/mobile_mcp_client.py | Mobile MCP + ADB fallback |
+| agents/device_testing/tools/ | Navigation tools (SoM, vision_click) |
+| agents/device_testing/tools/autonomous_navigation_tools.py | Core navigation + bbox annotation |
+| agents/device_testing/tools/agentic_vision_tools.py | GPT-5.2 vision-based click |
+| agents/device_testing/subagents/ | OAVR sub-agents (classifier, verifier, diagnosis) |
+| agents/device_testing/flicker_detection_service.py | 4-layer flicker detection |
+| agents/device_testing/golden_bug_service.py | Golden bug evaluation |
+| api/ | FastAPI route handlers |
+| api/ai_agent.py | SSE streaming AI chat endpoint |
+| api/device_simulation.py | Device/emulator discovery (2s cache) |
+| benchmarks/ | Android World benchmarks |
+| figma/ | Figma design analysis pipeline |
+| figma/flow_analyzer.py | 3-phase Figma flow analysis |
+| observability/tracing.py | LangSmith tracing |`,
+    frontend: `# Frontend (frontend/test-studio/src/)
+
+| Path | Purpose |
+|------|---------|
+| App.tsx | Main app with React Router |
+| pages/DemoPage.tsx | Split-screen demo (60% viewer, 40% chat) |
+| pages/LandingPage.tsx | Marketing homepage |
+| pages/PricingPage.tsx | Cloud pricing + enterprise |
+| pages/ChangelogPage.tsx | Version changelog |
+| components/emulator/ | Emulator HUD + WebSocket streaming |
+| components/DemoGate.tsx | Email gate for demo access |
+| hooks/ | Custom React hooks |
+
+Tech stack: React 18.3.1, TypeScript, Vite, TailwindCSS 4.x, shadcn/ui
+State: TanStack Query (server), React Context (client)
+Streaming: SSE for AI chat, WebSocket for emulator frames`,
+    agents: `# Agent Architecture
+
+## Hierarchy
+Coordinator (GPT-5.2) → Dynamic handoffs → Specialists
+├── Search Assistant — bug/scenario search
+├── Test Generation Specialist — test code generation
+└── Device Testing Specialist (GPT-5-mini) — mobile automation
+    └── OAVR Sub-agents
+        ├── Screen Classifier
+        ├── Action Verifier
+        └── Failure Diagnosis
+
+## Key Patterns
+- OpenAI Agents SDK with Runner.run_streamed()
+- Dynamic handoffs via is_enabled callbacks
+- SSE streaming to frontend
+- parallel_tool_calls=False for Device Testing (sequential navigation)
+- parallel_tool_calls=True for Coordinator (parallel orchestration)`,
+    scripts: `# Scripts
+
+| Path | Purpose |
+|------|---------|
+| backend/scripts/figma_cv_overlay.py | Direct CV overlay (no API calls) |
+| backend/scripts/test_figma_flow_analyzer.py | Figma flow analyzer test harness |
+| backend/scripts/test_flicker_detection.py | Flicker detection PoC |
+| backend/scripts/annotate_real_device.py | SoM annotation demo |
+| backend/scripts/ai_verify.py | LLM-based code verification |
+| scripts/demo-tunnel.sh | Demo tunnel setup |
+| scripts/setup-macos.sh | macOS dev environment setup |`,
+    integrations: `# Integrations
+
+## Chef (integrations/chef/)
+- Remix + React 18 + ai SDK 4.x
+- Convex backend
+- Braintrust evaluation harness
+- CRITICAL: Uses React 18 + ai SDK 4.x (TA frontend uses React 19 + ai SDK 5.x)
+- NEVER share node_modules between Chef and TA frontend
+
+## Chef Annotation System
+Three annotation types: usage, failure, model
+- JSON.parse on payloads MUST be wrapped in try-catch
+- encodeModelAnnotation must default provider to 'Unknown' (not null)
+- toolCallId must never be null — use call.toolCallId ?? 'unknown'
+- response.json() can only be called ONCE — store in variable`,
+    config: `# Key Configuration Files
+
+| File | Purpose |
+|------|---------|
+| .env | Environment variables (OPENAI_API_KEY) |
+| backend/requirements.txt | Python dependencies |
+| frontend/test-studio/package.json | Node dependencies |
+| playwright.config.ts | E2E test configuration |
+| package.json (root) | Root deps (@playwright/test, mcp-appium) |`,
+};
+export const CODEBASE_SECTION_LIST = Object.keys(CODEBASE_SECTIONS);
+//# sourceMappingURL=codebase-map.js.map

package/dist/knowledge/codebase-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codebase-map.js","sourceRoot":"","sources":["../../src/knowledge/codebase-map.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,CAAC,MAAM,iBAAiB,GAA2B;IACvD,QAAQ,EAAE;;;;;;;;;;;;qDAYyC;IAEnD,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;iDAuBsC;IAE/C,QAAQ,EAAE;;;;;;;;;;;;;;;0DAe8C;IAExD,MAAM,EAAE;;;;;;;;;;;;;;;;;oEAiB0D;IAElE,OAAO,EAAE;;;;;;;;;;yDAU8C;IAEvD,YAAY,EAAE;;;;;;;;;;;;;;8DAc8C;IAE5D,MAAM,EAAE;;;;;;;;mEAQyD;CAClE,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC"}

package/dist/knowledge/conventions.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Code conventions and style guidelines.
+ */
+export declare const CONVENTIONS = "# TA Studio Code Conventions\n\n## Python (Backend)\n- Imports: absolute imports from app. prefix\n- Type hints: Required for ALL function signatures\n- Docstrings: Google style for public functions\n- Async: Use async/await for I/O operations\n- Logging: Use logging.getLogger(__name__)\n\nExample:\n```python\nfrom app.agents.device_testing.mobile_mcp_client import MobileMCPClient\n\nasync def take_screenshot(device_id: str) -> str:\n    \"\"\"Take screenshot from device.\n    \n    Args:\n        device_id: Android device identifier\n        \n    Returns:\n        Base64-encoded screenshot data\n    \"\"\"\n    pass\n```\n\n## TypeScript (Frontend)\n- Components: Functional components with hooks, one per file\n- Types: Explicit types, avoid any\n- Imports: Use @/ path alias for src imports\n- State: React hooks for local state, TanStack Query for server state\n\nExample:\n```typescript\ninterface DeviceProps {\n  deviceId: string;\n  onStreamStart: (id: string) => void;\n}\nconst DeviceCard: React.FC<DeviceProps> = ({ deviceId, onStreamStart }) => { ... };\n```\n\n## Agent Code Patterns\n- Agent-as-tool pattern: coordinator delegates to specialized agents\n- Colocation: agent code + tools + models together\n- Factory pattern: agent creation via factory functions\n- DRY: no duplicate code across modules\n\n## Convex / Template Literals\n- Use \\n escape sequences (not multi-line templates) in Convex actions\n- Why: Easier to diff-review, auto-formatters don't mess indentation\n\n## Mobile MCP Data Shapes\n- Screenshots: { type: \"image\", data: \"base64...\", mimeType: \"image/jpeg\" }\n- ALWAYS keep structured, NEVER JSON.stringify for model consumption\n- Vision-ready: convert to data-URL: data:{mime};base64,{b64}\n\n## Critical Rules\n1. NEVER share node_modules between Chef (React 18) and TA frontend (React 19)\n2. NEVER commit without running verification\n3. ALWAYS auto-select first device (prefer emulator-5554)\n4. ALWAYS scale coordinates before drawing bounding boxes\n5. ALWAYS wrap JSON.parse in try-catch for external payloads\n6. ALWAYS use keyword arguments for functions with *, syntax\n7. NEVER pass async functions to asyncio.to_thread()\n";
+export declare const AGENT_CONFIG_REFERENCE = "# Agent Configuration Reference\n\n## Coordinator Agent\n- Model: gpt-5.2\n- parallel_tool_calls: True\n- reasoning: Reasoning(effort=\"high\")\n- Handoffs: Search Assistant, Test Generation, Device Testing\n- Instructions: General orchestration, task routing\n\n## Device Testing Agent\n- Model: gpt-5-mini (vision-capable)\n- parallel_tool_calls: False (CRITICAL \u2014 navigation is sequential)\n- reasoning: Reasoning(effort=\"medium\")\n- Tools: take_screenshot, list_elements, click, swipe, type, vision_click\n- Instructions: OAVR pattern, auto-select device, never ask user\n\n## Search Assistant\n- Model: gpt-5-mini\n- Purpose: Bug/scenario search in knowledge base\n\n## Test Generation Specialist\n- Model: gpt-5-mini\n- Purpose: Generate test code from bug descriptions\n\n## Streaming\n- SSE (Server-Sent Events) for AI chat responses\n- WebSocket for emulator frame streaming\n- OpenAI Agents SDK Runner.run_streamed() for agent execution\n";
+//# sourceMappingURL=conventions.d.ts.map

package/dist/knowledge/conventions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.d.ts","sourceRoot":"","sources":["../../src/knowledge/conventions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,WAAW,opEA+DvB,CAAC;AAEF,eAAO,MAAM,sBAAsB,g8BA4BlC,CAAC"}

package/dist/knowledge/conventions.js

@@ -0,0 +1,97 @@
+/**
+ * Code conventions and style guidelines.
+ */
+export const CONVENTIONS = `# TA Studio Code Conventions
+
+## Python (Backend)
+- Imports: absolute imports from app. prefix
+- Type hints: Required for ALL function signatures
+- Docstrings: Google style for public functions
+- Async: Use async/await for I/O operations
+- Logging: Use logging.getLogger(__name__)
+
+Example:
+\`\`\`python
+from app.agents.device_testing.mobile_mcp_client import MobileMCPClient
+
+async def take_screenshot(device_id: str) -> str:
+    """Take screenshot from device.
+    
+    Args:
+        device_id: Android device identifier
+        
+    Returns:
+        Base64-encoded screenshot data
+    """
+    pass
+\`\`\`
+
+## TypeScript (Frontend)
+- Components: Functional components with hooks, one per file
+- Types: Explicit types, avoid any
+- Imports: Use @/ path alias for src imports
+- State: React hooks for local state, TanStack Query for server state
+
+Example:
+\`\`\`typescript
+interface DeviceProps {
+  deviceId: string;
+  onStreamStart: (id: string) => void;
+}
+const DeviceCard: React.FC<DeviceProps> = ({ deviceId, onStreamStart }) => { ... };
+\`\`\`
+
+## Agent Code Patterns
+- Agent-as-tool pattern: coordinator delegates to specialized agents
+- Colocation: agent code + tools + models together
+- Factory pattern: agent creation via factory functions
+- DRY: no duplicate code across modules
+
+## Convex / Template Literals
+- Use \\n escape sequences (not multi-line templates) in Convex actions
+- Why: Easier to diff-review, auto-formatters don't mess indentation
+
+## Mobile MCP Data Shapes
+- Screenshots: { type: "image", data: "base64...", mimeType: "image/jpeg" }
+- ALWAYS keep structured, NEVER JSON.stringify for model consumption
+- Vision-ready: convert to data-URL: data:{mime};base64,{b64}
+
+## Critical Rules
+1. NEVER share node_modules between Chef (React 18) and TA frontend (React 19)
+2. NEVER commit without running verification
+3. ALWAYS auto-select first device (prefer emulator-5554)
+4. ALWAYS scale coordinates before drawing bounding boxes
+5. ALWAYS wrap JSON.parse in try-catch for external payloads
+6. ALWAYS use keyword arguments for functions with *, syntax
+7. NEVER pass async functions to asyncio.to_thread()
+`;
+export const AGENT_CONFIG_REFERENCE = `# Agent Configuration Reference
+
+## Coordinator Agent
+- Model: gpt-5.2
+- parallel_tool_calls: True
+- reasoning: Reasoning(effort="high")
+- Handoffs: Search Assistant, Test Generation, Device Testing
+- Instructions: General orchestration, task routing
+
+## Device Testing Agent
+- Model: gpt-5-mini (vision-capable)
+- parallel_tool_calls: False (CRITICAL — navigation is sequential)
+- reasoning: Reasoning(effort="medium")
+- Tools: take_screenshot, list_elements, click, swipe, type, vision_click
+- Instructions: OAVR pattern, auto-select device, never ask user
+
+## Search Assistant
+- Model: gpt-5-mini
+- Purpose: Bug/scenario search in knowledge base
+
+## Test Generation Specialist
+- Model: gpt-5-mini
+- Purpose: Generate test code from bug descriptions
+
+## Streaming
+- SSE (Server-Sent Events) for AI chat responses
+- WebSocket for emulator frame streaming
+- OpenAI Agents SDK Runner.run_streamed() for agent execution
+`;
+//# sourceMappingURL=conventions.js.map

package/dist/knowledge/conventions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.js","sourceRoot":"","sources":["../../src/knowledge/conventions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+D1B,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BrC,CAAC"}

package/dist/knowledge/known-issues.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Known issues database — every bug we've found and how we fixed it.
+ */
+export interface KnownIssue {
+    id: string;
+    title: string;
+    category: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    symptom: string;
+    rootCause: string;
+    fix: string;
+    file: string;
+    commit?: string;
+}
+export declare const KNOWN_ISSUES: KnownIssue[];
+export declare const ISSUE_CATEGORIES: string[];
+//# sourceMappingURL=known-issues.d.ts.map

package/dist/knowledge/known-issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-issues.d.ts","sourceRoot":"","sources":["../../src/knowledge/known-issues.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,YAAY,EAAE,UAAU,EAiGpC,CAAC;AAEF,eAAO,MAAM,gBAAgB,UAAkD,CAAC"}

package/dist/knowledge/known-issues.js

@@ -0,0 +1,103 @@
+/**
+ * Known issues database — every bug we've found and how we fixed it.
+ */
+export const KNOWN_ISSUES = [
+    {
+        id: 'bbox-coordinate-misalignment',
+        title: 'Bounding Box Coordinate Misalignment',
+        category: 'bbox_alignment',
+        severity: 'critical',
+        symptom: 'Bounding boxes drawn at completely wrong positions — labels and rectangles dont match actual UI elements. Elements appear off-screen.',
+        rootCause: 'Mobile MCP take_screenshot returns JPEG at ~45% of native resolution (486×1080) but list_elements_on_screen returns coordinates in native device resolution (1080×2400). Drawing at native coords on scaled image puts everything ~2.2x off-position.',
+        fix: 'Get device screen size via get_screen_size(), compute scale_x = img.width/screen_width, scale_y = img.height/screen_height, apply to all element coordinates before drawing.',
+        file: 'agents/device_testing/tools/autonomous_navigation_tools.py',
+        commit: 'c7e5a68',
+    },
+    {
+        id: 'missing-asyncio-import',
+        title: 'Missing asyncio Import',
+        category: 'import_errors',
+        severity: 'critical',
+        symptom: 'NameError: asyncio is not defined at line 552 (asyncio.to_thread call)',
+        rootCause: 'asyncio was used but never imported at module level.',
+        fix: 'Added import asyncio at line 10.',
+        file: 'agents/device_testing/tools/autonomous_navigation_tools.py',
+        commit: 'a3773ee',
+    },
+    {
+        id: 'async-def-in-to-thread',
+        title: 'async def passed to asyncio.to_thread()',
+        category: 'agent_chat',
+        severity: 'critical',
+        symptom: 'Bounding box drawing returns a coroutine object instead of results. SoM annotations silently fail.',
+        rootCause: '_draw_bounding_boxes_threaded was defined as async def but asyncio.to_thread() expects a synchronous function.',
+        fix: 'Changed async def _draw_bounding_boxes_threaded to def _draw_bounding_boxes_threaded (removed async).',
+        file: 'agents/device_testing/tools/autonomous_navigation_tools.py',
+        commit: 'a3773ee',
+    },
+    {
+        id: 'keyword-only-arg-mismatch',
+        title: 'Keyword-Only Argument Mismatch',
+        category: 'agent_chat',
+        severity: 'high',
+        symptom: 'TypeError on _bbox_find_label_position call — positional arguments passed to keyword-only parameters.',
+        rootCause: 'Function uses *, syntax (keyword-only args) but call site passes positional args.',
+        fix: 'Changed to keyword arguments: _bbox_find_label_position(x=x, y=y, width=width, ...)',
+        file: 'agents/device_testing/tools/autonomous_navigation_tools.py',
+        commit: 'a3773ee',
+    },
+    {
+        id: 'annotated-filepath-not-reset',
+        title: 'Annotated filepath not reset on bbox failure',
+        category: 'agent_chat',
+        severity: 'high',
+        symptom: 'FileNotFoundError when vision API tries to read annotated screenshot that doesnt exist.',
+        rootCause: 'annotated_filepath was set to the annotated path before drawing, but not reset when drawing fails.',
+        fix: 'Added annotated_filepath = filepath in the except handler (fallback to raw screenshot).',
+        file: 'agents/device_testing/tools/autonomous_navigation_tools.py',
+        commit: 'a3773ee',
+    },
+    {
+        id: 'agent-duplicate-device-calls',
+        title: 'Agent calls list_devices and start_navigation twice',
+        category: 'agent_chat',
+        severity: 'critical',
+        symptom: 'Agent calls list_available_devices AND start_navigation_session simultaneously, asks user which device, then hangs.',
+        rootCause: 'parallel_tool_calls=True on Device Testing Agent + no auto-select instructions.',
+        fix: 'Set parallel_tool_calls=False, added auto-select instructions (prefer emulator-5554), added NEVER ask user rule.',
+        file: 'agents/device_testing/device_testing_agent.py',
+        commit: 'a5fb8b4',
+    },
+    {
+        id: 'figma-images-rate-limit',
+        title: 'Figma Images API Rate Limit (Plan-Tier)',
+        category: 'figma_api',
+        severity: 'medium',
+        symptom: '429 on Figma REST API with Retry-After: 396156 (4.6 days)',
+        rootCause: 'Plan-tier rate limits on Figma Images API.',
+        fix: 'Use direct CV overlay (scripts/figma_cv_overlay.py) — captures browser screenshot via Playwright, detects flow groups via brightness thresholding + morphological connected components. No API calls needed.',
+        file: 'scripts/figma_cv_overlay.py',
+    },
+    {
+        id: 'openai-rate-limits',
+        title: 'OpenAI 429 Rate Limit Errors',
+        category: 'rate_limits',
+        severity: 'medium',
+        symptom: '429 errors from OpenAI API during heavy agent usage.',
+        rootCause: 'High token volume from verbose screen descriptions.',
+        fix: 'TOON format reduces tokens by 30-60%. Already integrated in autonomous_navigation_tools.py.',
+        file: 'agents/device_testing/tools/autonomous_navigation_tools.py',
+    },
+    {
+        id: 'chef-annotation-json-parse',
+        title: 'Chef Annotation Crashes (JSON.parse / Zod)',
+        category: 'chef_annotations',
+        severity: 'high',
+        symptom: 'UI render crashes, silent annotation drops, or response.json() failures.',
+        rootCause: 'Three bugs: 1) Unguarded JSON.parse in parseAnnotations, 2) Null provider/toolCallId in encodeModelAnnotation, 3) Double response.json() in recordUsage.',
+        fix: '1) Wrap JSON.parse in try-catch + continue on failure. 2) Default to "Unknown"/"unknown" not null. 3) Store await response.json() in variable, add early return on error.',
+        file: 'integrations/chef/app/lib/common/annotations.ts',
+    },
+];
+export const ISSUE_CATEGORIES = [...new Set(KNOWN_ISSUES.map(i => i.category))];
+//# sourceMappingURL=known-issues.js.map

package/dist/knowledge/known-issues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-issues.js","sourceRoot":"","sources":["../../src/knowledge/known-issues.ts"],"names":[],"mappings":"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"}

package/dist/knowledge/methodology.d.ts

@@ -0,0 +1,7 @@
+/**
+ * TA Studio methodology knowledge base.
+ * Each topic explains a pattern, technique, or architectural decision.
+ */
+export declare const METHODOLOGY_TOPICS: Record<string, string>;
+export declare const METHODOLOGY_TOPIC_LIST: string[];
+//# sourceMappingURL=methodology.d.ts.map

package/dist/knowledge/methodology.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methodology.d.ts","sourceRoot":"","sources":["../../src/knowledge/methodology.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAqFrD,CAAC;AAuHF,eAAO,MAAM,sBAAsB,UAAkC,CAAC"}

package/dist/knowledge/methodology.js

@@ -0,0 +1,200 @@
+/**
+ * TA Studio methodology knowledge base.
+ * Each topic explains a pattern, technique, or architectural decision.
+ */
+export const METHODOLOGY_TOPICS = {
+    overview: `# TA Studio Methodologies — Overview
+
+Available topics: oavr, som_annotation, coordinate_scaling, agent_config, flicker_detection, figma_flow, golden_bugs, mobile_mcp, vision_click, self_correction, closed_loop, device_auto_select, parallel_tool_calls
+
+## Architecture
+- **Backend**: FastAPI (Python 3.11+) at backend/
+- **Frontend**: React + TypeScript + Vite at frontend/test-studio/
+- **Mobile MCP**: Model Context Protocol for Android emulator control
+- **AI Agents**: Hierarchical multi-agent (Coordinator → Specialists)
+- **Models**: GPT-5.2 (coordinator, vision), GPT-5-mini (device testing)
+- **Streaming**: SSE for AI chat, WebSocket for emulator frames`,
+    oavr: `# OAVR Pattern — Observe-Act-Verify-Reason
+
+The device testing agent uses OAVR for autonomous navigation:
+
+1. **Observe** → Screen Classifier Agent analyzes current screen state
+2. **Act** → Execute action (click, swipe, type) via Mobile MCP
+3. **Verify** → Action Verifier confirms the action succeeded
+4. **Reason** → Failure Diagnosis suggests recovery if verification failed
+
+Key files:
+- agents/device_testing/subagents/screen_classifier_agent.py
+- agents/device_testing/subagents/action_verifier_agent.py
+- agents/device_testing/subagents/failure_diagnosis_agent.py
+
+The pattern ensures the agent doesn't blindly proceed after failed actions.`,
+    som_annotation: `# Set-of-Mark (SoM) Screenshot Annotation
+
+Based on OmniParser's SoM approach — color-coded, type-aware bounding boxes.
+
+## 9-Color Element Type Palette
+| Type      | Color       | Tag    | Example Classes                   |
+|-----------|-------------|--------|-----------------------------------|
+| button    | Dodger blue | BTN    | Button, ImageButton, FAB          |
+| input     | Orange      | INPUT  | EditText, SearchView              |
+| toggle    | Purple      | TOGGLE | Switch, CheckBox, RadioButton     |
+| nav       | Deep pink   | NAV    | BottomNavigationView, Toolbar     |
+| image     | Dark cyan   | IMG    | ImageView                         |
+| text      | Gray        | TXT    | TextView                          |
+| list      | Forest green| LIST   | RecyclerView, ListView            |
+| container | Dark gray   | BOX    | FrameLayout, LinearLayout         |
+| unknown   | Green       | ELEM   | Unclassified elements             |
+
+## Critical Rules
+1. Class map ordering: Specific substrings (radiobutton, compoundbutton) MUST precede generic ones (button) — first match wins
+2. Dual element format: Support both MCP nested (coordinates.width) and ADB flat (width) keys
+3. Resolution scaling: Font = width/54, line = width/360. Never use fixed pixel sizes
+4. Priority sorting: Interactive elements first, then by area descending
+5. Container filtering: Skip FrameLayout/LinearLayout/RelativeLayout to reduce noise
+
+Key file: agents/device_testing/tools/autonomous_navigation_tools.py`,
+    coordinate_scaling: `# Coordinate Scaling — Screenshot vs Device Resolution
+
+## The Problem
+Mobile MCP take_screenshot returns JPEG images scaled to ~45% of native resolution, but list_elements_on_screen returns coordinates in native device resolution.
+
+| Layer              | Resolution  | Source                           |
+|--------------------|-------------|----------------------------------|
+| Device screen      | 1080×2400   | Native resolution                |
+| Screenshot image   | 486×1080    | Mobile MCP compresses to JPEG    |
+| Element coordinates| 1080×2400   | list_elements_on_screen (native) |
+
+## The Fix
+1. Get device screen size: mobile_mcp_client.get_screen_size(device_id)
+   Returns: "Screen size is 1080x2400 pixels"
+2. Parse width/height with regex: r'(\\d+)\\s*x\\s*(\\d+)'
+3. Compute scale factors:
+   scale_x = img.width / screen_width  → 486/1080 = 0.45
+   scale_y = img.height / screen_height → 1080/2400 = 0.45
+4. Apply to ALL element coordinates before drawing:
+   x = int(raw_x * scale_x)
+   y = int(raw_y * scale_y)
+   width = int(raw_w * scale_x)
+   height = int(raw_h * scale_y)
+
+## Verification
+- Center element (540,1200) → (243,540) ✓
+- Bottom-right (1080,2400) → (486,1080) ✓
+- Without scaling: elements at y=1990 drawn on 1080-tall image → off-screen ✗
+
+Key file: autonomous_navigation_tools.py lines 397-595`,
+};
+// Additional topics added below to stay within file-size limits
+METHODOLOGY_TOPICS.agent_config = `# Agent Configuration Patterns
+
+## Coordinator Agent (GPT-5.2)
+- parallel_tool_calls=True (orchestration tasks can be parallel)
+- reasoning=Reasoning(effort="high")
+- Dynamic handoffs via is_enabled callbacks
+- Delegates to: Search Assistant, Test Generation Specialist, Device Testing Specialist
+
+## Device Testing Agent (GPT-5-mini)
+- parallel_tool_calls=False ← CRITICAL (navigation is sequential: observe→act→verify)
+- reasoning=Reasoning(effort="medium")
+- Auto-selects first device (prefers emulator-5554)
+- NEVER asks user to choose between devices
+
+## Why parallel_tool_calls=False for Device Testing
+Navigation is inherently sequential. With parallel=True, the agent was calling
+list_available_devices AND start_navigation_session simultaneously, then asking
+the user which device to use instead of auto-selecting. Setting it to False
+forces sequential execution: discover device → select → navigate.
+
+Key file: agents/device_testing/device_testing_agent.py`;
+METHODOLOGY_TOPICS.vision_click = `# Vision-Augmented Navigation (Sight-Based Interaction)
+
+When the accessibility tree (list_elements_on_screen) is insufficient (canvas-based UI,
+loading states), the agent uses Agentic Vision (GPT-5.2) to find elements visually.
+
+## Primary Tool: vision_click(query="...")
+1. Captures screenshot via Mobile MCP
+2. Sends to GPT-5.2 with reasoning for element identification
+3. GPT-5.2 returns pixel coordinates of the target element
+4. Executes coordinate click via Mobile MCP
+
+## Workflow: Think → Act → Verify
+- Think: GPT-5.2 analyzes screenshot, identifies target element
+- Act: Determine precise pixel coordinates
+- Verify: Coordinate click executed, verify screen changed
+
+Key file: agents/device_testing/tools/agentic_vision_tools.py`;
+METHODOLOGY_TOPICS.mobile_mcp = `# Mobile MCP Client Architecture
+
+## Connection
+- Spawns npx -y @mobilenext/mobile-mcp@latest as subprocess
+- Communicates via JSON-RPC over stdin/stdout
+- Auto-initializes with protocol version 2024-11-05
+
+## ADB Fallback
+When Mobile MCP returns "Device not found", automatically falls back to ADB:
+- click → adb shell input tap x y
+- type → adb shell input text "..."
+- press_button → adb shell input keyevent KEYCODE
+
+## Key Methods
+- take_screenshot(device) → returns JPEG base64 (scaled down ~45%)
+- list_elements_on_screen(device) → returns elements in NATIVE resolution
+- get_screen_size(device) → returns "Screen size is WxH pixels"
+- click_on_screen(device, x, y) → click at coordinates
+- swipe_on_screen(device, direction) → swipe gesture
+
+Key file: agents/device_testing/mobile_mcp_client.py`;
+METHODOLOGY_TOPICS.flicker_detection = `# Flicker Detection Pipeline — 4-Layer Architecture
+
+Detects screen flickers too fast for periodic screenshots (16-200ms).
+
+## Layers
+- Layer 0: SurfaceFlinger frame timing + logcat monitoring (always-on, zero cost)
+- Layer 1: adb screenrecord triggered recording (60fps H.264)
+- Layer 2: ffmpeg scene-filtered extraction + parallel SSIM analysis
+- Layer 3: GPT-5.2 vision verification (semantic bug vs animation classification)
+
+## Optimizations (19x speedup)
+- ffmpeg scene detection pre-filter (60-80% frame reduction)
+- JPEG extraction (5-10x smaller than PNG)
+- Parallel SSIM via ProcessPoolExecutor (3-5x speedup)
+- Adaptive threshold (median - 2σ)
+
+Key file: agents/device_testing/flicker_detection_service.py (1117 lines)`;
+METHODOLOGY_TOPICS.closed_loop = `# Closed-Loop Verification (Ralph Loop)
+
+Every change follows: THINK → ACT → VERIFY → OBSERVE → ADAPT → COMMIT
+
+## Verification Commands (Run Before Every Commit)
+Backend: cd backend && pytest --tb=short
+Frontend: cd frontend/test-studio && npm run build && npm run lint && npm run test -- --run
+E2E: npx playwright test tests/e2e/golden-bugs.spec.ts
+
+## Self-Correction Protocol
+1. Read the error — understand what broke
+2. Diagnose root cause — don't just patch symptoms
+3. Fix systematically — update code, tests, and docs together
+4. Re-verify — run full verification again
+5. Iterate — repeat until green
+
+NEVER commit without running verification!`;
+METHODOLOGY_TOPICS.device_auto_select = `# Device Auto-Selection
+
+## The Bug
+Agent was calling list_available_devices AND start_navigation_session twice each,
+asking the user which device to use, then hanging without executing the task.
+
+## The Fix
+1. Instructions updated: "Auto-select the first available device (prefer emulator-5554)"
+2. CRITICAL WORKFLOW section added: "NEVER ask user to choose between devices"
+3. parallel_tool_calls set to False on Device Testing Agent
+
+## Device Selection Priority
+1. emulator-5554 (default Android emulator)
+2. First emulator-* found
+3. First device in the list
+
+Key file: agents/device_testing/device_testing_agent.py`;
+export const METHODOLOGY_TOPIC_LIST = Object.keys(METHODOLOGY_TOPICS);
+//# sourceMappingURL=methodology.js.map

package/dist/knowledge/methodology.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methodology.js","sourceRoot":"","sources":["../../src/knowledge/methodology.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAA2B;IACxD,QAAQ,EAAE;;;;;;;;;;gEAUoD;IAE9D,IAAI,EAAE;;;;;;;;;;;;;;4EAcoE;IAE1E,cAAc,EAAE;;;;;;;;;;;;;;;;;;;;;;;;qEAwBmD;IAEnE,kBAAkB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDA6BiC;CACtD,CAAC;AAEF,gEAAgE;AAChE,kBAAkB,CAAC,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;wDAoBsB,CAAC;AAEzD,kBAAkB,CAAC,YAAY,GAAG;;;;;;;;;;;;;;;;8DAgB4B,CAAC;AAE/D,kBAAkB,CAAC,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;qDAoBqB,CAAC;AAEtD,kBAAkB,CAAC,iBAAiB,GAAG;;;;;;;;;;;;;;;;0EAgBmC,CAAC;AAE3E,kBAAkB,CAAC,WAAW,GAAG;;;;;;;;;;;;;;;;2CAgBU,CAAC;AAE5C,kBAAkB,CAAC,kBAAkB,GAAG;;;;;;;;;;;;;;;;wDAgBgB,CAAC;AAEzD,MAAM,CAAC,MAAM,sBAAsB,GAAG,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC"}

package/dist/knowledge/workflows.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Step-by-step workflows for common TA Studio tasks.
+ */
+export declare const WORKFLOWS: Record<string, string>;
+export declare const WORKFLOW_LIST: string[];
+export declare const QUICK_COMMANDS = "# Quick Commands\n\n## Backend\ncd backend && python -m uvicorn app.main:app --reload --port 8000\ncd backend && pytest --tb=short\ncd backend && python -m mypy app/ --ignore-missing-imports\n\n## Frontend\ncd frontend/test-studio && npm run dev\ncd frontend/test-studio && npm run build\ncd frontend/test-studio && npm run lint\ncd frontend/test-studio && npx tsc --noEmit\n\n## E2E\nnpx playwright test\nnpx playwright test --trace on\nnpx playwright show-report\n\n## Device\nadb devices\nadb shell wm size\nadb shell screencap -p /sdcard/screen.png && adb pull /sdcard/screen.png\n\n## Git\ngit add <files> && git diff --cached --stat\ngit commit -m \"fix: description\"\ngit push origin main";
+//# sourceMappingURL=workflows.d.ts.map

package/dist/knowledge/workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/knowledge/workflows.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA8G5C,CAAC;AAEF,eAAO,MAAM,aAAa,UAAyB,CAAC;AAEpD,eAAO,MAAM,cAAc,6rBA0BN,CAAC"}

package/dist/knowledge/workflows.js

@@ -0,0 +1,137 @@
+/**
+ * Step-by-step workflows for common TA Studio tasks.
+ */
+export const WORKFLOWS = {
+    bug_fix: `# Bug Fix Workflow
+
+1. DIAGNOSE — Read error logs, reproduce the issue
+   cd backend && tail -f /tmp/backend.log
+2. LOCATE — Find the affected file using codebase search
+3. ROOT CAUSE — Identify WHY, not just WHERE
+4. FIX — Make minimal, targeted change
+5. VERIFY — Run tests
+   cd backend && pytest --tb=short
+   cd frontend/test-studio && npm run build
+6. TEST E2E — If UI-related, run E2E
+   npx playwright test
+7. COMMIT — Only when all checks pass
+   git add <files> && git commit -m "fix: <description>"`,
+    navigation_test: `# Navigation Test Workflow
+
+1. ENSURE EMULATOR — adb devices (verify emulator-5554 connected)
+2. START BACKEND — cd backend && python -m uvicorn app.main:app --reload --port 8000
+3. START FRONTEND — cd frontend/test-studio && npm run dev
+4. OPEN DEMO — http://localhost:5173/demo
+5. SEND TASK — Type navigation task in chat (e.g. "go youtube find video for terry tricks")
+6. OBSERVE — Watch agent execute OAVR loop:
+   - Screenshots appear in emulator viewer
+   - SoM annotations show bounding boxes
+   - Agent narrates each step
+7. VERIFY ANNOTATIONS — Check bounding boxes align with actual elements
+   - If misaligned, check coordinate scaling (see: coordinate_scaling methodology)
+8. CHECK COMPLETION — Agent should report task complete with evidence`,
+    bbox_verify: `# Bounding Box Verification Workflow
+
+1. CAPTURE — Take screenshot via agent or manually:
+   ls -la backend/screenshots/emulator-5554_*_annotated.png
+2. COMPARE — Open raw and annotated screenshots side-by-side
+3. CHECK ALIGNMENT — Each bounding box should:
+   - Surround the correct UI element
+   - Have the right color for element type (see SoM palette)
+   - Label matches element text/type
+4. IF MISALIGNED:
+   a. Check device screen size: adb shell wm size → e.g. 1080x2400
+   b. Check screenshot size: python3 -c "from PIL import Image; print(Image.open('screenshot.png').size)"
+   c. Verify scale factors: scale_x = img_width / screen_width
+   d. Check autonomous_navigation_tools.py lines 397-448 for scaling code
+5. TEST FIX — Run navigation task and verify annotations`,
+    agent_debug: `# Agent Chat Debugging Workflow
+
+1. CHECK SERVICES:
+   curl http://localhost:8000/health
+   curl http://localhost:5173
+2. CHECK BACKEND LOGS:
+   tail -f /tmp/backend.log
+3. COMMON ISSUES:
+   - Agent hangs → Check parallel_tool_calls setting (should be False for device testing)
+   - Device not found → adb devices, check emulator running
+   - Screenshot fails → Check Mobile MCP process running
+   - Bbox wrong → Check coordinate scaling (methodology: coordinate_scaling)
+4. SSE STREAM DEBUG:
+   - Open browser DevTools → Network → filter "EventStream"
+   - Check for proper event format: data: {...}
+5. AGENT TRACE — Check LangSmith (if configured):
+   https://smith.langchain.com`,
+    feature: `# Feature Development Workflow
+
+1. PLAN — Define scope, affected files, architecture impact
+2. BRANCH — git checkout -b feature/<name>
+3. IMPLEMENT — Follow code style (Python: type hints + docstrings, TS: explicit types)
+4. TEST — Write unit tests alongside implementation
+5. VERIFY BACKEND:
+   cd backend && pytest --tb=short
+6. VERIFY FRONTEND:
+   cd frontend/test-studio && npm run build && npm run lint
+7. E2E — Test end-to-end if UI-related
+   npx playwright test
+8. REVIEW — Self-review diff before commit
+9. COMMIT — Descriptive commit message
+10. PUSH — git push origin feature/<name>`,
+    figma_analysis: `# Figma Flow Analysis Workflow
+
+1. GET API KEY — Figma Personal Access Token
+2. EXTRACT — Figma REST API (depth=3): DOC→CANVAS→SECTION→FRAME
+3. CLUSTER — Multi-signal priority cascade:
+   Sections → Prototype connections → Name prefixes → Spatial (Y-bin + X-gap)
+4. VISUALIZE — PIL bounding boxes on Figma canvas screenshots
+5. IF RATE-LIMITED — Use CV overlay (no API calls):
+   cd backend && python scripts/figma_cv_overlay.py
+   - Brightness thresholding (>80 for sections, >100 for frames)
+   - Morphological closing/opening (scipy.ndimage)
+   - Connected component analysis
+   
+Key files:
+- app/figma/flow_analyzer.py — Core pipeline
+- scripts/figma_cv_overlay.py — CV fallback`,
+    flicker_test: `# Flicker Detection Test Workflow
+
+1. ENSURE EMULATOR — adb devices
+2. START RECORDING — Layer 1 triggers adb screenrecord (60fps)
+3. REPRODUCE — Navigate to the screen with suspected flicker
+4. EXTRACT FRAMES — Layer 2 uses ffmpeg scene detection
+5. ANALYZE — Parallel SSIM comparison of consecutive frames
+6. VERIFY — Layer 3 sends suspicious frames to GPT-5.2 vision
+7. REPORT — Classified as bug (flicker/glitch) or animation (expected)
+
+Quick test:
+cd backend && python scripts/test_flicker_detection.py`,
+};
+export const WORKFLOW_LIST = Object.keys(WORKFLOWS);
+export const QUICK_COMMANDS = `# Quick Commands
+
+## Backend
+cd backend && python -m uvicorn app.main:app --reload --port 8000
+cd backend && pytest --tb=short
+cd backend && python -m mypy app/ --ignore-missing-imports
+
+## Frontend
+cd frontend/test-studio && npm run dev
+cd frontend/test-studio && npm run build
+cd frontend/test-studio && npm run lint
+cd frontend/test-studio && npx tsc --noEmit
+
+## E2E
+npx playwright test
+npx playwright test --trace on
+npx playwright show-report
+
+## Device
+adb devices
+adb shell wm size
+adb shell screencap -p /sdcard/screen.png && adb pull /sdcard/screen.png
+
+## Git
+git add <files> && git diff --cached --stat
+git commit -m "fix: description"
+git push origin main`;
+//# sourceMappingURL=workflows.js.map

package/dist/knowledge/workflows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.js","sourceRoot":"","sources":["../../src/knowledge/workflows.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,CAAC,MAAM,SAAS,GAA2B;IAC/C,OAAO,EAAE;;;;;;;;;;;;;yDAa8C;IAEvD,eAAe,EAAE;;;;;;;;;;;;;sEAamD;IAEpE,WAAW,EAAE;;;;;;;;;;;;;;yDAc0C;IAEvD,WAAW,EAAE;;;;;;;;;;;;;;;;+BAgBgB;IAE7B,OAAO,EAAE;;;;;;;;;;;;;;0CAc+B;IAExC,cAAc,EAAE;;;;;;;;;;;;;;;4CAe0B;IAE1C,YAAY,EAAE;;;;;;;;;;;uDAWuC;CACtD,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAEpD,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BT,CAAC"}

package/dist/tools/register-all.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Register all TA Studio MCP tools on a McpServer instance.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAllTools(server: McpServer): void;
+//# sourceMappingURL=register-all.d.ts.map

package/dist/tools/register-all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-all.d.ts","sourceRoot":"","sources":["../../src/tools/register-all.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAQzE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAoIxD"}

package/dist/tools/register-all.js

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { METHODOLOGY_TOPICS, METHODOLOGY_TOPIC_LIST } from '../knowledge/methodology.js';
+import { KNOWN_ISSUES, ISSUE_CATEGORIES } from '../knowledge/known-issues.js';
+import { CODEBASE_SECTIONS, CODEBASE_SECTION_LIST } from '../knowledge/codebase-map.js';
+import { WORKFLOWS, WORKFLOW_LIST, QUICK_COMMANDS } from '../knowledge/workflows.js';
+import { CONVENTIONS, AGENT_CONFIG_REFERENCE } from '../knowledge/conventions.js';
+export function registerAllTools(server) {
+    // ─── 1. getMethodology ───
+    server.registerTool('getMethodology', {
+        title: 'TA Studio Methodology',
+        description: `Get detailed methodology for a TA Studio pattern or technique. Topics: ${METHODOLOGY_TOPIC_LIST.join(', ')}. Use "overview" to see all topics.`,
+        inputSchema: {
+            topic: z.string().describe(`Topic name. Available: ${METHODOLOGY_TOPIC_LIST.join(', ')}`),
+        },
+    }, async ({ topic }) => {
+        const content = METHODOLOGY_TOPICS[topic];
+        if (!content) {
+            return {
+                content: [{ type: 'text', text: `Unknown topic "${topic}". Available: ${METHODOLOGY_TOPIC_LIST.join(', ')}` }],
+            };
+        }
+        return { content: [{ type: 'text', text: content }] };
+    });
+    // ─── 2. getKnownIssues ───
+    server.registerTool('getKnownIssues', {
+        title: 'TA Studio Known Issues',
+        description: `Get known issues and their fixes. Categories: ${ISSUE_CATEGORIES.join(', ')}. Omit category for all issues.`,
+        inputSchema: {
+            category: z.string().optional().describe(`Filter by category: ${ISSUE_CATEGORIES.join(', ')}`),
+        },
+    }, async ({ category }) => {
+        const issues = category
+            ? KNOWN_ISSUES.filter(i => i.category === category)
+            : KNOWN_ISSUES;
+        if (issues.length === 0) {
+            return {
+                content: [{ type: 'text', text: `No issues found for category "${category}". Available: ${ISSUE_CATEGORIES.join(', ')}` }],
+            };
+        }
+        const text = issues.map(i => `## [${i.severity.toUpperCase()}] ${i.title}\n` +
+            `**ID**: ${i.id}\n` +
+            `**Symptom**: ${i.symptom}\n` +
+            `**Root Cause**: ${i.rootCause}\n` +
+            `**Fix**: ${i.fix}\n` +
+            `**File**: ${i.file}` +
+            (i.commit ? `\n**Commit**: ${i.commit}` : '')).join('\n\n---\n\n');
+        return { content: [{ type: 'text', text: `# Known Issues (${issues.length})\n\n${text}` }] };
+    });
+    // ─── 3. getCodebaseMap ───
+    server.registerTool('getCodebaseMap', {
+        title: 'TA Studio Codebase Map',
+        description: `Get codebase structure and file purposes. Sections: ${CODEBASE_SECTION_LIST.join(', ')}. Use "overview" for full map.`,
+        inputSchema: {
+            section: z.string().optional().describe(`Section: ${CODEBASE_SECTION_LIST.join(', ')}. Default: overview`),
+        },
+    }, async ({ section }) => {
+        const key = section || 'overview';
+        const content = CODEBASE_SECTIONS[key];
+        if (!content) {
+            return {
+                content: [{ type: 'text', text: `Unknown section "${key}". Available: ${CODEBASE_SECTION_LIST.join(', ')}` }],
+            };
+        }
+        return { content: [{ type: 'text', text: content }] };
+    });
+    // ─── 4. getWorkflow ───
+    server.registerTool('getWorkflow', {
+        title: 'TA Studio Workflows',
+        description: `Get step-by-step workflow. Available: ${WORKFLOW_LIST.join(', ')}.`,
+        inputSchema: {
+            name: z.string().describe(`Workflow name: ${WORKFLOW_LIST.join(', ')}`),
+        },
+    }, async ({ name }) => {
+        const content = WORKFLOWS[name];
+        if (!content) {
+            return {
+                content: [{ type: 'text', text: `Unknown workflow "${name}". Available: ${WORKFLOW_LIST.join(', ')}` }],
+            };
+        }
+        return { content: [{ type: 'text', text: content }] };
+    });
+    // ─── 5. getQuickCommands ───
+    server.registerTool('getQuickCommands', {
+        title: 'TA Studio Quick Commands',
+        description: 'Get all quick development commands for backend, frontend, E2E, device, and git.',
+    }, async () => {
+        return { content: [{ type: 'text', text: QUICK_COMMANDS }] };
+    });
+    // ─── 6. getConventions ───
+    server.registerTool('getConventions', {
+        title: 'TA Studio Code Conventions',
+        description: 'Get code style guidelines, patterns, and critical rules for Python backend and TypeScript frontend.',
+    }, async () => {
+        return { content: [{ type: 'text', text: CONVENTIONS }] };
+    });
+    // ─── 7. getAgentConfig ───
+    server.registerTool('getAgentConfig', {
+        title: 'TA Studio Agent Configuration',
+        description: 'Get full agent configuration reference — models, parallel_tool_calls, reasoning levels, handoffs, and streaming setup.',
+    }, async () => {
+        return { content: [{ type: 'text', text: AGENT_CONFIG_REFERENCE }] };
+    });
+}
+//# sourceMappingURL=register-all.js.map

package/dist/tools/register-all.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-all.js","sourceRoot":"","sources":["../../src/tools/register-all.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "ta-studio-mcp",
+  "version": "1.0.0",
+  "description": "TA Studio MCP — Domain knowledge, patterns, bug fixes, and workflows for AI agents working on the TA Studio mobile test automation platform.",
+  "type": "module",
+  "bin": {
+    "ta-studio-mcp": "dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TA-Studios-AI-Avengers/ta-agent-examples.git",
+    "directory": "packages/ta-studio-mcp"
+  },
+  "homepage": "https://github.com/TA-Studios-AI-Avengers/ta-agent-examples/tree/main/packages/ta-studio-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/TA-Studios-AI-Avengers/ta-agent-examples/issues"
+  },
+  "author": "TA Studios",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mobile-testing",
+    "android",
+    "test-automation",
+    "ai-agents",
+    "ta-studio",
+    "claude",
+    "openai",
+    "agentic",
+    "oavr",
+    "som-annotation",
+    "device-testing",
+    "screenshot-annotation"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.21.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.4"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}