agent-dispatch 0.3.0__tar.gz → 0.4.0__tar.gz

{agent_dispatch-0.3.0 → agent_dispatch-0.4.0}/CHANGELOG.md

@@ -7,6 +7,68 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-05-15
+
+### Added
+- Result references — `dispatch(..., return_ref=True)` and per-item in
+  `dispatch_parallel` now return a compact `{ref, agent, success, size,
+  summary, summary_chars, cost_usd, ...}` payload instead of the full
+  result text. The full DispatchResult is persisted to disk (reusing the
+  async JobStore) and can be loaded on demand via the new
+  `fetch_result(ref, max_chars=0)` MCP tool. Saves caller context when
+  the result is large; the JSON parsed_result (small by nature) is still
+  inlined alongside the ref. fetch_result also works on any
+  `dispatch_async` job_id — the storage is shared.
+- `JobStore.create_completed(...)` — persists an already-finished
+  DispatchResult as a Job in terminal state. Used by ref mode; future
+  iterations can use it for result archival.
+- Structured JSON response support — `dispatch`, `dispatch_session`,
+  `dispatch_async`, `dispatch_stream`, and per-item in `dispatch_parallel`
+  now accept `response_format="json"`. When set, the runner appends a clear
+  "respond with a single JSON value, no prose, no fences" footer to the
+  prompt and attempts to parse the agent's response (tolerating ```json
+  fences). The parsed value lands in a new `DispatchResult.parsed_result`
+  field — `None` when not requested or unparseable (soft mode: parse
+  failure does NOT mark the dispatch as failed). Cache key now includes
+  `response_format` so JSON and text requests for the same task don't
+  collide.
+- `list_agents` MCP tool now surfaces `mcp_servers`, `stacks`, and `dbs`
+  per agent (when present) — the same structured data `auto_describe`
+  already collects from `.mcp.json`, `Dockerfile`, `pyproject.toml`,
+  `package.json`, `Cargo.toml`, `go.mod`, `prisma/`, `alembic.ini`, etc.
+  Calling agents no longer need to dispatch a probe just to learn what
+  tools the target has.
+- New `inspect_agent(name, preview_lines=40)` MCP tool — cheap detailed
+  lookup without a `claude` subprocess. Returns the agent's full config
+  fields (timeout, model, budget, permission_mode, tool lists), detected
+  MCP/stacks/DBs, plus short previews of `CLAUDE.md` and `README.md` so
+  the caller can confirm capabilities before spending a real dispatch.
+- `config.collect_mcp_servers()`, `config.detect_stacks()`, and
+  `config.detect_dbs()` are now public helpers (the previous private
+  `_collect_mcp_servers` remains as an alias for compatibility).
+- Async dispatch with a `job_id` pattern — five new MCP tools let calling
+  agents fire-and-forget long-running tasks without blocking their own tool
+  slot:
+  - `dispatch_async(agent, task, ...)` — start a dispatch in the background,
+    returns `{job_id, status: "pending", agent}` immediately.
+  - `dispatch_status(job_id)` — read the current state of a job without
+    blocking (pending / running / done / failed) including the
+    `DispatchResult` once complete.
+  - `dispatch_wait(job_id, timeout_seconds=60)` — block until terminal or
+    until the timeout fires (capped at 3600s). Returns the same shape as
+    `dispatch_status` plus `timed_out_waiting: true` on timeout — the job
+    keeps running and the caller can poll/wait again.
+  - `dispatch_jobs(status?, limit=50)` — list recent jobs as summaries,
+    optionally filtered by status (most recent first).
+  - `dispatch_gc(max_age_days=7)` — purge terminal jobs older than the
+    threshold. Pending and running jobs are never touched.
+- Job state persists to disk as one JSON file per job under
+  `~/.config/agent-dispatch/jobs/` (override via `AGENT_DISPATCH_JOBS_DIR`).
+  Atomic writes via `os.replace()` so partial files never appear, and jobs
+  survive across server restarts (existing terminal jobs remain queryable,
+  in-flight jobs are abandoned on restart — to be addressed in a future
+  iteration with PID tracking).
+
 ## [0.3.0] - 2026-05-08
 
 ### Added
@@ -90,7 +152,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Dependabot for `pip` + `github-actions`, GitHub Actions pinned to
   commit SHAs for supply-chain integrity.
 
-[Unreleased]: https://github.com/ginkida/agent-dispatch/compare/v0.3.0...HEAD
+[Unreleased]: https://github.com/ginkida/agent-dispatch/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/ginkida/agent-dispatch/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/ginkida/agent-dispatch/compare/v0.2.2...v0.3.0
 [0.2.2]: https://github.com/ginkida/agent-dispatch/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/ginkida/agent-dispatch/compare/v0.2.0...v0.2.1

{agent_dispatch-0.3.0 → agent_dispatch-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-dispatch
-Version: 0.3.0
+Version: 0.4.0
 Summary: MCP server that lets Claude Code agents delegate tasks to agents in other project directories
 Project-URL: Homepage, https://github.com/ginkida/agent-dispatch
 Project-URL: Repository, https://github.com/ginkida/agent-dispatch
@@ -85,7 +85,7 @@ Done. Every Claude Code session now has access to all dispatch tools.
 Lists all configured agents. **Call this first** to see what's available.
 
 ```json
-// Response (permission fields shown only when configured)
+// Response (capability + permission fields shown only when populated)
 [
   {
     "name": "infra",
@@ -94,12 +94,28 @@ Lists all configured agents. **Call this first** to see what's available.
     "healthy": true,
     "has_claude_md": true,
     "has_mcp_config": true,
+    "mcp_servers": ["portainer", "postgres"],
+    "stacks": ["Python", "Docker"],
+    "dbs": ["Alembic"],
     "permission_mode": "bypassPermissions",
     "allowed_tools": ["Bash", "Read", "Grep"]
   }
 ]
 ```
 
+`mcp_servers`, `stacks`, and `dbs` are detected from the agent's project files (`.mcp.json`, `Dockerfile`, `pyproject.toml`, `Cargo.toml`, `prisma/`, `alembic.ini`, etc.) so callers can pick the right agent without dispatching a probe.
+
+### `inspect_agent`
+
+Cheap detailed lookup — reads the agent's files without spawning a `claude` session. Returns the full config (timeout, model, budget, permission mode, allowed/disallowed tools), detected MCP/stacks/DBs, plus short previews of `CLAUDE.md` and `README.md` when present.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `name` | string | yes | Agent name from `list_agents` |
+| `preview_lines` | int | no | Max lines of CLAUDE.md/README.md (default 40, max 200, 0 disables) |
+
+Use this **before** `dispatch_async`/`dispatch` to confirm an agent has the tools and context for your task — much cheaper than a probe dispatch.
+
 ### `dispatch`
 
 One-shot task delegation. Results are cached — identical requests within TTL return instantly.
@@ -111,6 +127,9 @@ One-shot task delegation. Results are cached — identical requests within TTL r
 | `context` | string | no | Extra context: error messages, code snippets, stack traces |
 | `caller` | string | no | Your project/role — helps the agent understand who's asking |
 | `goal` | string | no | Broader objective — helps the agent make better trade-offs |
+| `response_format` | string | no | `"json"` to request a single JSON value; the parsed result lands in `parsed_result`. Empty = free-form text. |
+| `return_ref` | bool | no | When `true`, returns just a `ref` + summary preview instead of the full result text. Use `fetch_result(ref)` to load the full text on demand. |
+| `summary_chars` | int | no | Max chars of result text to include in the ref response (default 500). |
 
 ```json
 // Response (success)
@@ -136,6 +155,18 @@ One-shot task delegation. Results are cached — identical requests within TTL r
 
 **`error_type` values:** `permission` (tool/action denied), `timeout`, `recursion` (dispatch depth exceeded), `not_found` (missing directory or CLI), `cli_error` (other failures). Permission errors include an actionable hint.
 
+**Structured JSON output:** pass `response_format="json"` to ask the agent for a single JSON value. The runner appends an instruction footer ("respond with a single valid JSON value, no fences, no prose") and on success parses the response — the parsed value lands in `parsed_result`. The raw text is always in `result`. Parse failures leave `parsed_result=None` but don't fail the dispatch (soft mode).
+
+```json
+// Response with response_format="json"
+{
+  "agent": "infra",
+  "success": true,
+  "result": "{\"errors\": 3, \"first_at\": \"14:02\"}",
+  "parsed_result": {"errors": 3, "first_at": "14:02"}
+}
+```
+
 **Always pass `caller` and `goal`** — the dispatched agent sees a structured prompt:
 
 ```markdown
@@ -290,6 +321,55 @@ Remove an agent from config.
 
 View cache hit rate and size, or clear all cached results.
 
+### Result references — `return_ref` + `fetch_result`
+
+For dispatches whose result text is large (audits, log dumps, code searches), passing the full text back inflates the calling agent's context. Use `return_ref=True` to get just a small reference instead:
+
+```
+dispatch(agent="infra", task="audit every container", return_ref=True, summary_chars=200)
+  -> {"ref": "8f3a...e1", "agent": "infra", "success": true,
+      "size": 14823, "summary_chars": 200,
+      "summary": "Inspected 32 containers. Found 3 OOM kills in the last hour:\n- worker-3...",
+      "cost_usd": 0.08, "duration_ms": 9200}
+
+// Later, when you actually need to read the result:
+fetch_result(ref="8f3a...e1")              -> full DispatchResult JSON
+fetch_result(ref="8f3a...e1", max_chars=2000)  -> truncated, plus {"truncated": true, "full_size": 14823}
+```
+
+Refs reuse the same storage as `dispatch_async` jobs (under `~/.config/agent-dispatch/jobs/`), so any `job_id` returned by `dispatch_async` is also a valid `ref` for `fetch_result`. `parsed_result` (when `response_format="json"` is set) is small and is always inlined directly in the ref response — no second fetch needed.
+
+### Async dispatch — `dispatch_async`, `dispatch_status`, `dispatch_wait`, `dispatch_jobs`, `dispatch_gc`
+
+When a dispatched task is going to take a while, you don't want to block your own tool slot for minutes. Async dispatch returns a `job_id` immediately and lets you check back when you're ready.
+
+```
+// 1. fire and forget
+dispatch_async(agent="infra", task="audit every container log for OOM kills today")
+  -> {"job_id": "8f3a...e1", "status": "pending", "agent": "infra"}
+
+// 2. do other work, then check progress (non-blocking)
+dispatch_status(job_id="8f3a...e1")
+  -> {"id": "8f3a...e1", "status": "running", "started_at": 1730000123.4, ...}
+
+// 3. or block until done (with a timeout cap)
+dispatch_wait(job_id="8f3a...e1", timeout_seconds=120)
+  -> {"id": "8f3a...e1", "status": "done", "result": {"agent": "infra", "success": true, ...}}
+
+// If the timeout fires, the job keeps running:
+  -> {"id": "...", "status": "running", "timed_out_waiting": true}
+```
+
+`dispatch_jobs(status?)` lists recent jobs as summaries (filter by `pending` / `running` / `done` / `failed` / `cancelled`). `dispatch_gc(max_age_days=7)` purges terminal jobs older than the threshold — pending and running jobs are never deleted.
+
+Job state persists to disk at `~/.config/agent-dispatch/jobs/` (override with `AGENT_DISPATCH_JOBS_DIR`). One JSON file per job, atomic writes — safe to read or `ls` while jobs are in flight.
+
+| When to use async | When to use `dispatch` |
+|-------------------|------------------------|
+| Long task (minutes) — you want to keep working | Short task — you need the answer right now |
+| Several long tasks you'll collect later | Several short tasks → `dispatch_parallel` |
+| Don't care about caching (each call is a fresh job) | Cached by default — identical requests are free |
+
 ### Error Responses
 
 All tools return errors as:
@@ -308,6 +388,8 @@ All tools return errors as:
 | Long task, want to see progress | `dispatch_stream` |
 | Two agents need to collaborate | `dispatch_dialogue` |
 | Need a combined summary from multiple agents | `dispatch_parallel` with `aggregate` |
+| Long task — don't block your tool slot | `dispatch_async` + `dispatch_wait` |
+| Check progress without blocking | `dispatch_status` |
 
 ## Configuration
 

{agent_dispatch-0.3.0 → agent_dispatch-0.4.0}/README.md

@@ -55,7 +55,7 @@ Done. Every Claude Code session now has access to all dispatch tools.
 Lists all configured agents. **Call this first** to see what's available.
 
 ```json
-// Response (permission fields shown only when configured)
+// Response (capability + permission fields shown only when populated)
 [
   {
     "name": "infra",
@@ -64,12 +64,28 @@ Lists all configured agents. **Call this first** to see what's available.
     "healthy": true,
     "has_claude_md": true,
     "has_mcp_config": true,
+    "mcp_servers": ["portainer", "postgres"],
+    "stacks": ["Python", "Docker"],
+    "dbs": ["Alembic"],
     "permission_mode": "bypassPermissions",
     "allowed_tools": ["Bash", "Read", "Grep"]
   }
 ]
 ```
 
+`mcp_servers`, `stacks`, and `dbs` are detected from the agent's project files (`.mcp.json`, `Dockerfile`, `pyproject.toml`, `Cargo.toml`, `prisma/`, `alembic.ini`, etc.) so callers can pick the right agent without dispatching a probe.
+
+### `inspect_agent`
+
+Cheap detailed lookup — reads the agent's files without spawning a `claude` session. Returns the full config (timeout, model, budget, permission mode, allowed/disallowed tools), detected MCP/stacks/DBs, plus short previews of `CLAUDE.md` and `README.md` when present.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `name` | string | yes | Agent name from `list_agents` |
+| `preview_lines` | int | no | Max lines of CLAUDE.md/README.md (default 40, max 200, 0 disables) |
+
+Use this **before** `dispatch_async`/`dispatch` to confirm an agent has the tools and context for your task — much cheaper than a probe dispatch.
+
 ### `dispatch`
 
 One-shot task delegation. Results are cached — identical requests within TTL return instantly.
@@ -81,6 +97,9 @@ One-shot task delegation. Results are cached — identical requests within TTL r
 | `context` | string | no | Extra context: error messages, code snippets, stack traces |
 | `caller` | string | no | Your project/role — helps the agent understand who's asking |
 | `goal` | string | no | Broader objective — helps the agent make better trade-offs |
+| `response_format` | string | no | `"json"` to request a single JSON value; the parsed result lands in `parsed_result`. Empty = free-form text. |
+| `return_ref` | bool | no | When `true`, returns just a `ref` + summary preview instead of the full result text. Use `fetch_result(ref)` to load the full text on demand. |
+| `summary_chars` | int | no | Max chars of result text to include in the ref response (default 500). |
 
 ```json
 // Response (success)
@@ -106,6 +125,18 @@ One-shot task delegation. Results are cached — identical requests within TTL r
 
 **`error_type` values:** `permission` (tool/action denied), `timeout`, `recursion` (dispatch depth exceeded), `not_found` (missing directory or CLI), `cli_error` (other failures). Permission errors include an actionable hint.
 
+**Structured JSON output:** pass `response_format="json"` to ask the agent for a single JSON value. The runner appends an instruction footer ("respond with a single valid JSON value, no fences, no prose") and on success parses the response — the parsed value lands in `parsed_result`. The raw text is always in `result`. Parse failures leave `parsed_result=None` but don't fail the dispatch (soft mode).
+
+```json
+// Response with response_format="json"
+{
+  "agent": "infra",
+  "success": true,
+  "result": "{\"errors\": 3, \"first_at\": \"14:02\"}",
+  "parsed_result": {"errors": 3, "first_at": "14:02"}
+}
+```
+
 **Always pass `caller` and `goal`** — the dispatched agent sees a structured prompt:
 
 ```markdown
@@ -260,6 +291,55 @@ Remove an agent from config.
 
 View cache hit rate and size, or clear all cached results.
 
+### Result references — `return_ref` + `fetch_result`
+
+For dispatches whose result text is large (audits, log dumps, code searches), passing the full text back inflates the calling agent's context. Use `return_ref=True` to get just a small reference instead:
+
+```
+dispatch(agent="infra", task="audit every container", return_ref=True, summary_chars=200)
+  -> {"ref": "8f3a...e1", "agent": "infra", "success": true,
+      "size": 14823, "summary_chars": 200,
+      "summary": "Inspected 32 containers. Found 3 OOM kills in the last hour:\n- worker-3...",
+      "cost_usd": 0.08, "duration_ms": 9200}
+
+// Later, when you actually need to read the result:
+fetch_result(ref="8f3a...e1")              -> full DispatchResult JSON
+fetch_result(ref="8f3a...e1", max_chars=2000)  -> truncated, plus {"truncated": true, "full_size": 14823}
+```
+
+Refs reuse the same storage as `dispatch_async` jobs (under `~/.config/agent-dispatch/jobs/`), so any `job_id` returned by `dispatch_async` is also a valid `ref` for `fetch_result`. `parsed_result` (when `response_format="json"` is set) is small and is always inlined directly in the ref response — no second fetch needed.
+
+### Async dispatch — `dispatch_async`, `dispatch_status`, `dispatch_wait`, `dispatch_jobs`, `dispatch_gc`
+
+When a dispatched task is going to take a while, you don't want to block your own tool slot for minutes. Async dispatch returns a `job_id` immediately and lets you check back when you're ready.
+
+```
+// 1. fire and forget
+dispatch_async(agent="infra", task="audit every container log for OOM kills today")
+  -> {"job_id": "8f3a...e1", "status": "pending", "agent": "infra"}
+
+// 2. do other work, then check progress (non-blocking)
+dispatch_status(job_id="8f3a...e1")
+  -> {"id": "8f3a...e1", "status": "running", "started_at": 1730000123.4, ...}
+
+// 3. or block until done (with a timeout cap)
+dispatch_wait(job_id="8f3a...e1", timeout_seconds=120)
+  -> {"id": "8f3a...e1", "status": "done", "result": {"agent": "infra", "success": true, ...}}
+
+// If the timeout fires, the job keeps running:
+  -> {"id": "...", "status": "running", "timed_out_waiting": true}
+```
+
+`dispatch_jobs(status?)` lists recent jobs as summaries (filter by `pending` / `running` / `done` / `failed` / `cancelled`). `dispatch_gc(max_age_days=7)` purges terminal jobs older than the threshold — pending and running jobs are never deleted.
+
+Job state persists to disk at `~/.config/agent-dispatch/jobs/` (override with `AGENT_DISPATCH_JOBS_DIR`). One JSON file per job, atomic writes — safe to read or `ls` while jobs are in flight.
+
+| When to use async | When to use `dispatch` |
+|-------------------|------------------------|
+| Long task (minutes) — you want to keep working | Short task — you need the answer right now |
+| Several long tasks you'll collect later | Several short tasks → `dispatch_parallel` |
+| Don't care about caching (each call is a fresh job) | Cached by default — identical requests are free |
+
 ### Error Responses
 
 All tools return errors as:
@@ -278,6 +358,8 @@ All tools return errors as:
 | Long task, want to see progress | `dispatch_stream` |
 | Two agents need to collaborate | `dispatch_dialogue` |
 | Need a combined summary from multiple agents | `dispatch_parallel` with `aggregate` |
+| Long task — don't block your tool slot | `dispatch_async` + `dispatch_wait` |
+| Check progress without blocking | `dispatch_status` |
 
 ## Configuration
 

{agent_dispatch-0.3.0 → agent_dispatch-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-dispatch"
-version = "0.3.0"
+version = "0.4.0"
 description = "MCP server that lets Claude Code agents delegate tasks to agents in other project directories"
 readme = "README.md"
 license = "MIT"

{agent_dispatch-0.3.0 → agent_dispatch-0.4.0}/src/agent_dispatch/__init__.py

@@ -1,3 +1,3 @@
 """agent-dispatch: Delegate tasks between Claude Code agents across projects."""
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"

{agent_dispatch-0.3.0 → agent_dispatch-0.4.0}/src/agent_dispatch/cache.py

@@ -16,11 +16,11 @@ logger = logging.getLogger(__name__)
 class DispatchCache:
     """Thread-safe TTL cache for dispatch results.
 
-    Keyed on (agent, task, context, caller, goal) — identical requests within
-    the TTL window return the cached result without spawning a new subprocess.
-    `caller` and `goal` affect the prompt sent to the agent, so they must be
-    part of the key: otherwise two requests with different framing would
-    collide and return the wrong response.
+    Keyed on (agent, task, context, caller, goal, response_format) — identical
+    requests within the TTL window return the cached result without spawning a
+    new subprocess. ``caller``/``goal``/``response_format`` all affect the
+    prompt sent to the agent, so they must be part of the key: otherwise two
+    requests with different framing would collide and return the wrong response.
     """
 
     def __init__(self, ttl: int = 300) -> None:
@@ -37,6 +37,7 @@ class DispatchCache:
         context: str | None,
         caller: str | None = None,
         goal: str | None = None,
+        response_format: str | None = None,
     ) -> str:
         canonical = json.dumps(
             {
@@ -45,6 +46,7 @@ class DispatchCache:
                 "context": context or "",
                 "caller": caller or "",
                 "goal": goal or "",
+                "response_format": response_format or "",
             },
             sort_keys=True,
         )
@@ -57,8 +59,9 @@ class DispatchCache:
         context: str | None = None,
         caller: str | None = None,
         goal: str | None = None,
+        response_format: str | None = None,
     ) -> DispatchResult | None:
-        key = self._make_key(agent, task, context, caller, goal)
+        key = self._make_key(agent, task, context, caller, goal, response_format)
         with self._lock:
             entry = self._store.get(key)
             if entry is None:
@@ -80,10 +83,11 @@ class DispatchCache:
         context: str | None = None,
         caller: str | None = None,
         goal: str | None = None,
+        response_format: str | None = None,
     ) -> None:
         if not result.success:
             return  # don't cache failures
-        key = self._make_key(agent, task, context, caller, goal)
+        key = self._make_key(agent, task, context, caller, goal, response_format)
         with self._lock:
             self._store[key] = (time.monotonic(), result)
 

{agent_dispatch-0.3.0 → agent_dispatch-0.4.0}/src/agent_dispatch/config.py

@@ -60,6 +60,47 @@ def _collect_mcp_servers(directory: Path) -> list[str]:
     return list(dict.fromkeys(servers))  # deduplicate, preserve order
 
 
+# Public alias — callers outside config.py should use this name.
+collect_mcp_servers = _collect_mcp_servers
+
+
+def detect_stacks(directory: Path) -> list[str]:
+    """Detect language/runtime stacks present in a project directory.
+
+    Returns a deduplicated list of indicators like ["Python", "Docker"].
+    Used by auto_describe() and by the MCP list_agents tool to surface
+    capabilities cheaply (no claude subprocess needed).
+    """
+    indicators: list[str] = []
+    if (directory / "Dockerfile").exists():
+        indicators.append("Docker")
+    if (directory / "docker-compose.yaml").exists() or (
+        directory / "docker-compose.yml"
+    ).exists():
+        indicators.append("Docker Compose")
+    if (directory / "Cargo.toml").exists():
+        indicators.append("Rust")
+    if (directory / "go.mod").exists():
+        indicators.append("Go")
+    if (directory / "requirements.txt").exists() or (directory / "pyproject.toml").exists():
+        indicators.append("Python")
+    if (directory / "package.json").exists():
+        indicators.append("Node.js")
+    return indicators
+
+
+def detect_dbs(directory: Path) -> list[str]:
+    """Detect database-related artifacts: Prisma, Alembic, generic migrations dir."""
+    indicators: list[str] = []
+    if (directory / "prisma").is_dir() or (directory / "schema.prisma").exists():
+        indicators.append("Prisma")
+    if (directory / "alembic").is_dir() or (directory / "alembic.ini").exists():
+        indicators.append("Alembic")
+    if (directory / "migrations").is_dir():
+        indicators.append("migrations")
+    return indicators
+
+
 def auto_describe(directory: Path) -> str:
     """Generate agent description by reading project files.
 
@@ -122,32 +163,14 @@ def auto_describe(directory: Path) -> str:
     if servers:
         parts.append(f"MCP: {', '.join(servers)}")
 
-    # Stack indicators
-    indicators = []
-    if (directory / "Dockerfile").exists():
-        indicators.append("Docker")
-    if (directory / "docker-compose.yaml").exists() or (directory / "docker-compose.yml").exists():
-        indicators.append("Docker Compose")
-    if (directory / "Cargo.toml").exists():
-        indicators.append("Rust")
-    if (directory / "go.mod").exists():
-        indicators.append("Go")
-    if (directory / "requirements.txt").exists() or pyproject.exists():
-        indicators.append("Python")
-    if pkg_json.exists():
-        indicators.append("Node.js")
-    if indicators:
-        parts.append(f"Stack: {', '.join(indicators)}")
+    # Stack indicators (Python/Node/Rust/Go/Docker)
+    stacks = detect_stacks(directory)
+    if stacks:
+        parts.append(f"Stack: {', '.join(stacks)}")
 
-    # Database indicators
-    db_indicators = []
-    if (directory / "prisma").is_dir() or (directory / "schema.prisma").exists():
-        db_indicators.append("Prisma")
-    if (directory / "alembic").is_dir() or (directory / "alembic.ini").exists():
-        db_indicators.append("Alembic")
-    if (directory / "migrations").is_dir():
-        db_indicators.append("migrations")
-    if db_indicators:
-        parts.append(f"DB: {', '.join(db_indicators)}")
+    # Database indicators (Prisma/Alembic/migrations)
+    dbs = detect_dbs(directory)
+    if dbs:
+        parts.append(f"DB: {', '.join(dbs)}")
 
     return " | ".join(parts) if parts else f"Agent in {directory.name}"