wicked-garden 12.27.0

package/scripts/smaht/adapters/delegation_adapter.py

@@ -0,0 +1,104 @@
+"""
+Delegation advisor adapter for wicked-smaht.
+
+Analyzes prompts to suggest specialist delegation when domain-specific work is detected.
+"""
+
+import sys
+from typing import List
+
+from . import ContextItem
+
+
+# Domain-to-specialist mapping for delegation hints
+DOMAIN_HINTS = {
+    "security": ("wicked-garden:platform", "security-engineer", "Security review"),
+    "architecture": ("wicked-garden:engineering", "solution-architect", "Architecture analysis"),
+    "test": ("wicked-garden:qe", "test-strategist", "Test strategy"),
+    "data": ("wicked-garden:data", "data-engineer", "Data analysis"),
+    "brainstorm": ("wicked-garden:jam", "facilitator", "Brainstorming session"),
+    "requirements": ("wicked-garden:product", "requirements-analyst", "Requirements elicitation"),
+    "agent": ("wicked-garden:agentic", "architect", "Agentic system review"),
+
+    "review": ("wicked-garden:crew", "reviewer", "Code review"),
+    "debug": ("wicked-garden:engineering", "solution-architect", "Debugging / root-cause analysis"),
+    "performance": ("wicked-garden:platform", "performance-engineer", "Performance analysis"),
+    "ux": ("wicked-garden:product", "ux-researcher", "UX research"),
+    "compliance": ("wicked-garden:platform", "compliance-auditor", "Compliance review"),
+}
+
+# Keywords that suggest delegatable work
+DOMAIN_KEYWORDS = {
+    "security": ["security", "auth", "encrypt", "vulnerability", "owasp", "csrf", "xss", "secure", "authentication", "authorization"],
+    "architecture": ["architecture", "design", "system design", "component", "api contract", "scalability", "microservice"],
+    "test": ["test", "testing", "coverage", "scenario", "qa", "quality", "e2e", "integration test", "unit test"],
+    "data": ["data", "analytics", "pipeline", "etl", "database", "query", "csv", "sql", "warehouse"],
+    "brainstorm": ["brainstorm", "ideas", "explore", "alternatives", "perspectives", "ideation"],
+    "requirements": ["requirements", "user story", "acceptance criteria", "stakeholder", "feature request"],
+    "agent": ["agent", "agentic", "llm", "prompt", "guardrail", "tool use", "subagent"],
+    "review": ["review", "code review", "pull request", "pr review", "peer review"],
+    "debug": ["debug", "error", "bug", "stacktrace", "root cause", "investigate", "troubleshoot"],
+    "performance": ["performance", "latency", "throughput", "bottleneck", "optimize", "profiling"],
+    "ux": ["ux", "user experience", "usability", "user research", "user flow", "interaction"],
+    "compliance": ["compliance", "audit", "regulatory", "gdpr", "hipaa", "sox", "policy"],
+}
+
+
+async def query(prompt: str, **kwargs) -> List[ContextItem]:
+    """Return delegation hints for the given prompt."""
+    prompt_lower = prompt.lower()
+    items = []
+    detected_domains = []
+
+    # Detect all matching domains
+    for domain, keywords in DOMAIN_KEYWORDS.items():
+        if any(kw in prompt_lower for kw in keywords):
+            detected_domains.append(domain)
+
+    # Create delegation hints for each detected domain
+    for domain in detected_domains:
+        plugin, agent, desc = DOMAIN_HINTS[domain]
+        hint_text = (
+            f"{desc} detected — consider delegating to specialist:\n"
+            f"Task(subagent_type=\"{plugin}:{agent}\", prompt=\"...\")"
+        )
+
+        items.append(ContextItem(
+            id=f"delegation-{domain}",
+            source="delegation",
+            title=f"Delegation: {desc}",
+            summary=f"Consider: {plugin}:{agent}",
+            excerpt=hint_text,
+            relevance=0.7,  # High relevance for actionable delegation advice
+            age_days=0,
+            metadata={
+                "domain": domain,
+                "plugin": plugin,
+                "agent": agent,
+                "type": "delegation_hint",
+            }
+        ))
+
+    # Suggest parallel dispatch if multiple specialists applicable
+    if len(detected_domains) > 1:
+        parallel_hint = (
+            f"{len(detected_domains)} specialist domains detected "
+            f"({', '.join(detected_domains)}) — "
+            f"use parallel Task dispatches for efficiency"
+        )
+
+        items.append(ContextItem(
+            id="delegation-parallel",
+            source="delegation",
+            title="Parallel Delegation Opportunity",
+            summary=f"{len(detected_domains)} specialists applicable",
+            excerpt=parallel_hint,
+            relevance=0.8,  # Higher relevance for efficiency pattern
+            age_days=0,
+            metadata={
+                "domains": detected_domains,
+                "type": "parallel_hint",
+            }
+        ))
+
+    return items

package/scripts/smaht/adapters/domain_adapter.py

@@ -0,0 +1,206 @@
+"""
+DomainStore adapter for wicked-smaht.
+
+Queries crew projects and jam sessions via DomainStore directly (local
+JSON with optional MCP routing). Replaces cp_adapter.py which queried
+the same data via HTTP.
+
+Strategy:
+1. Query each domain using DomainStore (local JSON primary store)
+2. Apply generic relevance scoring (keyword matching + status/type boosts)
+3. Return ContextItems sorted by relevance
+"""
+
+import asyncio
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List
+
+from . import ContextItem, _SCRIPTS_ROOT, run_in_thread
+
+if str(_SCRIPTS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_ROOT))
+
+
+# ---------------------------------------------------------------------------
+# Stop words for keyword extraction
+# ---------------------------------------------------------------------------
+
+_STOP_WORDS = frozenset({
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "have", "has",
+    "had", "do", "does", "did", "will", "would", "could", "should", "can",
+    "may", "might", "must", "i", "you", "we", "they", "me", "my", "your",
+    "this", "that", "these", "those", "what", "which", "who", "how", "why",
+    "when", "where", "and", "or", "but", "if", "for", "of", "to", "from",
+    "in", "on", "at", "by", "with", "about", "not", "so", "just", "also",
+    "need", "want", "let", "get", "make", "test", "check", "fix", "work",
+})
+
+
+# ---------------------------------------------------------------------------
+# Domain query configuration (mirrors cp_adapter._DOMAIN_QUERIES structure)
+# Each entry defines how to fetch data from a DomainStore domain.
+#
+#   domain_name:  DomainStore("wicked-{name}") argument
+#   source:       DomainStore collection name (first arg to .list()/.search())
+#   label:        ContextItem source label
+#   project_key:  record field used for project scoping (None = no scoping)
+#   title_fn:     callable(record) → title string
+#   summary_fn:   callable(record) → summary string
+#   boost_fn:     callable(record) → float bonus (0.0-0.5)
+# ---------------------------------------------------------------------------
+
+_DOMAIN_QUERIES = [
+    {
+        "domain_name": "wicked-crew",
+        "source": "projects",
+        "label": "crew",
+        "project_key": None,  # crew projects are not sub-scoped
+        "title_fn": lambda r: f"Project: {r.get('name', '?')} ({r.get('current_phase', '?')} phase)",
+        "summary_fn": lambda r: f"Phase: {r.get('current_phase', '?')}, Complexity: {r.get('complexity_score', 0)}/7",
+        "boost_fn": lambda r: (
+            0.4 if not r.get("archived", False) and r.get("current_phase") not in ("done", "review") else 0.0
+        ),
+    },
+    {
+        "domain_name": "jam",
+        "source": "sessions",
+        "label": "jam",
+        "project_key": "project",
+        "title_fn": lambda r: f"Brainstorm: {r.get('topic', '')}",
+        "summary_fn": lambda r: (r.get("summary") or r.get("synthesis", {}).get("summary", ""))[:200],
+        "boost_fn": lambda r: 0.0,
+    },
+]
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _extract_keywords(prompt: str) -> str:
+    words = prompt.lower().split()
+    keywords = [w for w in words if w not in _STOP_WORDS and len(w) > 2]
+    return " ".join(keywords[:5]) if keywords else ""
+
+
+def _keyword_score(prompt_lower: str, text: str, weight: float = 0.2) -> float:
+    """Score text by keyword overlap with prompt."""
+    if not text:
+        return 0.0
+    text_lower = text.lower()
+    score = 0.0
+    for word in prompt_lower.split():
+        if len(word) > 3 and word in text_lower:
+            score += weight
+    return min(score, 0.5)
+
+
+# ---------------------------------------------------------------------------
+# Per-domain query (runs in thread pool)
+# ---------------------------------------------------------------------------
+
+def _query_domain(config: dict, keywords: str, project: str = "") -> list:
+    """Query a single DomainStore domain. Runs in thread pool.
+
+    Uses _skip_discovery=True to bypass integration-discovery (MCP routing).
+    This is a read-only context query — smaht never needs to delegate reads
+    to external tools, and discovery can block for up to 3 s when brain is
+    slow, which exceeds the fast-path 0.5 s timeout (issue #374).
+
+    Returns a list of raw record dicts, or [] on any error.
+    """
+    try:
+        from _domain_store import DomainStore
+
+        ds = DomainStore(config["domain_name"], _skip_discovery=True)
+
+        params: dict = {}
+        if keywords:
+            params["q"] = keywords
+        if project and config.get("project_key"):
+            params[config["project_key"]] = project
+
+        records = ds.list(config["source"], **params)
+        return records if isinstance(records, list) else []
+    except Exception:
+        return []
+
+
+# ---------------------------------------------------------------------------
+# Public async query function
+# ---------------------------------------------------------------------------
+
+async def query(prompt: str, project: str = None) -> List[ContextItem]:
+    """Query crew projects and jam sessions via DomainStore for relevant context.
+
+    Args:
+        prompt: The user's query/prompt text.
+        project: Optional project filter (applied to project-scoped domains).
+
+    Returns:
+        List of ContextItems sorted by relevance descending.
+    """
+    keywords = _extract_keywords(prompt)
+    if not keywords:
+        return []
+
+    prompt_lower = prompt.lower()
+    items: list[ContextItem] = []
+    now = datetime.now(timezone.utc)
+
+    # Query all domains in parallel to avoid serial blocking (issue #374).
+    domain_results = await asyncio.gather(
+        *[run_in_thread(_query_domain, config, keywords, project or "")
+          for config in _DOMAIN_QUERIES],
+        return_exceptions=True,
+    )
+
+    for config, records in zip(_DOMAIN_QUERIES, domain_results):
+        # Skip domains that raised (run_in_thread wraps; gather returns exception objects)
+        if isinstance(records, Exception) or not isinstance(records, list):
+            continue
+
+        for record in records[:10]:  # Cap per domain
+            # Skip archived or deleted records
+            if record.get("archived") or record.get("deleted"):
+                continue
+
+            title = config["title_fn"](record)
+            summary = config["summary_fn"](record)
+
+            # Score: base + keyword match + domain-specific boost
+            base = 0.3
+            kw_score = _keyword_score(prompt_lower, f"{title} {summary}")
+            boost = config["boost_fn"](record)
+            relevance = min(base + kw_score + boost, 1.0)
+
+            # Calculate age in days
+            age_days = 0.0
+            created = record.get("created_at") or record.get("created") or ""
+            if created:
+                try:
+                    dt = datetime.fromisoformat(created.replace("Z", "+00:00"))
+                    age_days = (now - dt).days
+                except Exception:
+                    pass  # fail open: age_days defaults to 0
+
+            items.append(ContextItem(
+                id=record.get("id", record.get("name", "")),
+                source=config["label"],
+                title=title,
+                summary=summary,
+                excerpt=summary,
+                relevance=relevance,
+                age_days=age_days,
+                metadata={
+                    "domain": config["domain_name"],
+                    "semantic_score": relevance,
+                },
+            ))
+
+    # Sort by relevance descending
+    items.sort(key=lambda x: x.relevance, reverse=True)
+    return items

package/scripts/smaht/adapters/events_adapter.py

@@ -0,0 +1,231 @@
+"""
+Event log adapter for wicked-smaht context assembly.
+
+Queries the unified event log (events.db) for recent cross-domain activity
+relevant to the current prompt. Surfaces crew phase transitions, jam decisions,
+native task changes, and other domain events alongside traditional context sources.
+
+This adapter complements brain_adapter (which queries memories) by providing
+the broader activity timeline that memories alone don't capture.
+"""
+
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List
+
+from . import ContextItem, _SCRIPTS_ROOT, run_in_thread
+
+if str(_SCRIPTS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_ROOT))
+
+
+_STOP_WORDS = frozenset({
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "have", "has",
+    "had", "do", "does", "did", "will", "would", "could", "should", "can",
+    "may", "might", "must", "i", "you", "we", "they", "me", "my", "your",
+    "this", "that", "these", "those", "what", "which", "who", "how", "why",
+    "when", "where", "and", "or", "but", "if", "for", "of", "to", "from",
+    "in", "on", "at", "by", "with", "about", "not", "so", "just", "also",
+})
+
+# Action patterns that indicate high-value events for context
+_HIGH_VALUE_ACTIONS = {
+    "phases.": 0.3,       # Crew phase transitions
+    "projects.created": 0.25,
+    "sessions.created": 0.2,  # Jam sessions
+    "memories.created": 0.15,
+    "tasks.": 0.1,        # Native task changes (base; event_type may boost further)
+}
+
+# Event type boosts (for native task events carrying event_type in metadata)
+_EVENT_TYPE_BOOSTS = {
+    "gate-finding": 0.4,
+    "phase-transition": 0.35,
+    "procedure-trigger": 0.3,
+    "coding-task": 0.2,
+    "subtask": 0.15,
+    "task": 0.0,  # regular tasks get no extra boost
+}
+
+
+def _extract_keywords(prompt: str) -> str:
+    words = prompt.lower().split()
+    keywords = [w for w in words if w not in _STOP_WORDS and len(w) > 2]
+    return " ".join(keywords[:6]) if keywords else ""
+
+
+def _query_events(prompt: str) -> list:
+    """Query EventStore for relevant events. Runs in thread pool."""
+    try:
+        from _event_store import EventStore
+        EventStore.ensure_schema()
+
+        results = []
+
+        # Strategy 1: FTS search with prompt keywords
+        keywords = _extract_keywords(prompt)
+        if keywords:
+            fts_results = EventStore.query(fts=keywords, since="30d", limit=10)
+            results.extend(fts_results)
+
+        # Strategy 2: Recent high-value events (last 7 days)
+        recent = EventStore.query(since="7d", limit=20)
+        seen_ids = {r.get("event_id") for r in results}
+        for event in recent:
+            if event.get("event_id") not in seen_ids:
+                results.append(event)
+
+        return results[:15]  # Cap total
+
+    except Exception:
+        return []
+
+
+def _action_boost(action: str) -> float:
+    """Score boost based on action type."""
+    for prefix, boost in _HIGH_VALUE_ACTIONS.items():
+        if action.startswith(prefix):
+            return boost
+    return 0.0
+
+
+def _chain_boost(payload_dict: dict, active_chain_id: "str | None") -> float:
+    """Score boost when event belongs to the active chain.
+
+    Chain-matched events score 0.65 base boost (combined with 0.15 base → 0.8 total).
+    Partial chain prefix match (parent chain) scores 0.45.
+    No chain match: 0.0.
+    """
+    if not active_chain_id:
+        return 0.0
+    event_chain = payload_dict.get("chain_id", "")
+    if not event_chain:
+        return 0.0
+    if event_chain == active_chain_id:
+        return 0.65
+    # Parent chain match: active is a.b.c, event is a.b → partial match
+    if active_chain_id.startswith(event_chain + "."):
+        return 0.45
+    # Child chain match: active is a.b, event is a.b.c → also relevant
+    if event_chain.startswith(active_chain_id + "."):
+        return 0.50
+    return 0.0
+
+
+def _get_active_chain_id() -> "str | None":
+    """Read active chain_id from session state."""
+    try:
+        from _session import SessionState
+        state = SessionState.load()
+        return getattr(state, "active_chain_id", None)
+    except Exception:
+        return None
+
+
+def _age_days(ts_str: str) -> float:
+    """Calculate age in days from ISO timestamp."""
+    try:
+        event_time = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+        delta = datetime.now(timezone.utc) - event_time
+        return max(delta.total_seconds() / 86400, 0.0)
+    except Exception:
+        return 30.0  # Default to old if unparseable
+
+
+async def query(prompt: str) -> List[ContextItem]:
+    """Query unified event log for cross-domain activity relevant to prompt.
+
+    Returns ContextItems tagged with source="events" so the context assembler
+    can distinguish event-sourced context from memory or domain-sourced context.
+    """
+    events = await run_in_thread(_query_events, prompt)
+    if not events:
+        return []
+
+    active_chain_id = await run_in_thread(_get_active_chain_id)
+
+    items: list[ContextItem] = []
+    prompt_lower = prompt.lower()
+
+    for event in events:
+        domain = event.get("domain", "unknown")
+        action = event.get("action", "unknown")
+        record_id = event.get("record_id", "")
+        ts = event.get("ts", "")
+        payload = event.get("payload", "")
+        project_id = event.get("project_id", "")
+
+        # Parse payload if it's a JSON string
+        payload_dict: dict = {}
+        if payload and isinstance(payload, str):
+            try:
+                payload_dict = json.loads(payload)
+            except Exception:
+                pass  # fail open
+
+        # Build title and summary
+        title = f"{domain}.{action}"
+        summary_parts = []
+
+        if action == "tasks.created":
+            task_name = payload_dict.get("name", "").strip()
+            if not task_name:
+                continue  # skip bare UUID entries — no meaningful name
+            title = f"{domain}.{action}: {task_name}"
+            summary_parts.append(task_name)
+        else:
+            if record_id:
+                summary_parts.append(record_id)
+            if project_id:
+                summary_parts.append(f"project: {project_id}")
+            if payload and isinstance(payload, str) and len(payload) < 200:
+                summary_parts.append(payload)
+
+        summary = " | ".join(summary_parts) if summary_parts else action
+
+        # Score: base + action boost + event_type boost + keyword match + recency + chain
+        base = 0.15
+        action_score = _action_boost(action)
+        event_type_val = payload_dict.get("event_type", "task")
+        event_type_score = _EVENT_TYPE_BOOSTS.get(event_type_val, 0.0)
+        keyword_score = 0.0
+        search_text = f"{title} {summary} {record_id} {project_id}".lower()
+        for word in prompt_lower.split():
+            if len(word) > 2 and word in search_text:
+                keyword_score += 0.1
+
+        age = _age_days(ts)
+        recency_boost = max(0.0, 0.15 - (age / 30) * 0.15)  # 0.15 for today, 0 for 30d ago
+
+        chain_score = _chain_boost(payload_dict, active_chain_id)
+        relevance = min(
+            base + action_score + event_type_score + keyword_score + recency_boost + chain_score,
+            1.0,
+        )
+
+        items.append(ContextItem(
+            id=event.get("event_id", ""),
+            source="events",
+            title=title,
+            summary=summary,
+            excerpt=(
+                f"[{ts[:10]}] {title}"
+                if action == "tasks.created"
+                else (f"[{ts[:10]}] {title}: {record_id}" if record_id else f"[{ts[:10]}] {title}")
+            ),
+            relevance=relevance,
+            age_days=age,
+            metadata={
+                "domain": domain,
+                "action": action,
+                "project_id": project_id,
+                "event_ts": ts,
+                "chain_id": payload_dict.get("chain_id", ""),
+            },
+        ))
+
+    # Sort by relevance descending
+    items.sort(key=lambda x: x.relevance, reverse=True)
+    return items[:10]

package/scripts/smaht/adapters/tools_adapter.py

@@ -0,0 +1,49 @@
+"""Tools adapter — surfaces available third-party CLIs for context assembly."""
+import subprocess
+
+
+def _check_cli(name):
+    """Check if a CLI tool is available."""
+    try:
+        result = subprocess.run(
+            ["which", name], capture_output=True, text=True, timeout=2
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+# Known third-party CLIs that wicked-garden skills orchestrate
+KNOWN_CLIS = {
+    "codex": {"skill": "wicked-garden:jam:council", "desc": "OpenAI Codex for code review and generation"},
+    "gemini": {"skill": "wicked-garden:jam:council", "desc": "Google Gemini for multi-modal AI tasks"},
+    "copilot": {"skill": "wicked-garden:jam:council", "desc": "GitHub Copilot CLI for AI-assisted coding"},
+    "opencode": {"skill": "wicked-garden:jam:council", "desc": "OpenCode for AI-assisted coding"},
+    "agent-browser": {"skill": "wicked-garden:agent-browser", "desc": "Browser automation and scraping"},
+}
+
+
+async def query(prompt: str, **kwargs) -> list:
+    """Return available CLI tools that could help with the current task."""
+    from dataclasses import dataclass
+
+    @dataclass
+    class ContextItem:
+        source: str
+        title: str
+        summary: str
+
+    results = []
+    available = []
+
+    for cli_name, info in KNOWN_CLIS.items():
+        if _check_cli(cli_name):
+            available.append(
+                ContextItem(
+                    source="tools",
+                    title=f"{cli_name} available",
+                    summary=f"{info['desc']} — Use /{info['skill']}"
+                )
+            )
+
+    return available