execution-engine-analysislisted
Install: claude install-skill aiskillstore/marketplace
# Execution Engine Analysis
Analyzes the control flow substrate and concurrency model.
## Process
1. **Identify async model** — Native async, sync-with-wrappers, or hybrid
2. **Classify topology** — DAG, FSM, or linear chain
3. **Catalog events** — Callbacks, listeners, generators
4. **Map observability** — Pre/post hooks, interception points
## Concurrency Model Classification
### Native Async
```python
# Signature: async/await throughout
async def run(self):
result = await self.llm.agenerate(messages)
return await self.process(result)
# Entry point uses asyncio
asyncio.run(agent.run())
```
**Indicators**: `async def`, `await`, `asyncio.gather`, `aiohttp`
### Sync with Wrappers
```python
# Signature: sync API wrapping async internals
def run(self):
return asyncio.run(self._async_run())
# Or using thread pools
def run(self):
with ThreadPoolExecutor() as pool:
future = pool.submit(self._blocking_call)
return future.result()
```
**Indicators**: `asyncio.run()` inside sync methods, `ThreadPoolExecutor`, `run_in_executor`
### Hybrid
```python
# Both sync and async APIs exposed
def invoke(self, input):
return self._sync_invoke(input)
async def ainvoke(self, input):
return await self._async_invoke(input)
```
**Indicators**: Paired methods (`invoke`/`ainvoke`), `sync_to_async` decorators
## Execution Topology
### DAG (Directed Acyclic Graph)
```python
# Signature: Nodes with dependencies
class Node:
def __init__(self, de