wicked-garden 12.27.0

package/hooks/scripts/prompt_submit.py

@@ -0,0 +1,1109 @@
+#!/usr/bin/env python3
+"""
+UserPromptSubmit hook — wicked-garden pull-model context assembly.
+
+v6 replaced the v5 push-model orchestrator (deleted in #428) with a pull-model
+architecture. The hook is now responsible only for session-level concerns:
+  - Setup gate (hard-block / onboarding directive)
+  - Facilitator re-evaluation directive (v6 Gate 3, #428)
+  - Turn counter increment
+  - Session goal capture (turns 1-2)
+  - HOT fast-exit on continuation tokens
+  - Pull-model directive injection (tiny, ~60-150 chars)
+  - Jam / discovery suggestion (signal-gated)
+  - Output formatting
+
+v9.2.11 removed the periodic [Memory] nudge that fired every 10 turns.
+Periodic reminders without a real signal are noise — Claude knows about
+wicked-brain:memory from CLAUDE.md and uses it when there is something
+to checkpoint. The proper checkpoint is the wicked-brain-session-teardown
+agent at session end, not a 10-turn timer.
+
+Subagents pull context on demand via wicked-brain:search/query and
+wicked-garden:search rather than having a briefing pushed every turn.
+The hook is stdlib-only.
+
+Always fails open — any unhandled exception returns {"continue": true}.
+"""
+
+import json
+import os
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Mapping
+
+# Add shared scripts directory to path.
+_PLUGIN_ROOT = Path(os.environ.get("CLAUDE_PLUGIN_ROOT", Path(__file__).resolve().parents[2]))
+_SCRIPTS_DIR = _PLUGIN_ROOT / "scripts"
+sys.path.insert(0, str(_SCRIPTS_DIR))
+
+def _resolve_brain_port():
+    try:
+        from _brain_port import resolve_port
+        return resolve_port()
+    except Exception:
+        return int(os.environ.get("WICKED_BRAIN_PORT", "4242"))
+
+
+# ---------------------------------------------------------------------------
+# Ops logger wrapper — fail-silent, never crashes the hook
+# ---------------------------------------------------------------------------
+
+def _log(domain, level, event, ok=True, ms=None, detail=None):
+    """Ops logger — fail-silent, never crashes the hook."""
+    try:
+        from _logger import log
+        log(domain, level, event, ok=ok, ms=ms, detail=detail)
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Session goal capture (turns 1-2)
+# ---------------------------------------------------------------------------
+
+def _brain_api(action, params=None, timeout=3):
+    """Call brain API. Returns parsed JSON or None."""
+    try:
+        import urllib.request
+        port = _resolve_brain_port()
+        payload = json.dumps({"action": action, "params": params or {}}).encode("utf-8")
+        req = urllib.request.Request(
+            f"http://localhost:{port}/api",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except Exception:
+        return None
+
+
+def _write_brain_memory(title, content, tier="episodic", tags=None, mem_type="episodic", importance=5):
+    """Write a memory chunk to brain. Returns chunk_id or None."""
+    try:
+        import uuid
+        mem_id = str(uuid.uuid4())
+        chunk_id = f"memories/{tier}/mem-{mem_id}"
+        chunk_path = Path.home() / ".wicked-brain" / f"{chunk_id}.md"
+        chunk_path.parent.mkdir(parents=True, exist_ok=True)
+
+        tags_list = tags or []
+        now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+        lines = ["---"]
+        lines.append("source: wicked-brain:memory")
+        lines.append(f"memory_type: {mem_type}")
+        lines.append(f"memory_tier: {tier}")
+        lines.append(f"title: {title}")
+        lines.append(f"importance: {importance}")
+        lines.append("contains:")
+        for t in tags_list:
+            lines.append(f"  - {t}")
+        lines.append(f'indexed_at: "{now}"')
+        lines.append("---")
+        lines.append("")
+        lines.append(f"# {title}")
+        lines.append("")
+        lines.append(content)
+
+        chunk_path.write_text("\n".join(lines), encoding="utf-8")
+
+        # Index in brain FTS5
+        search_text = f"{title} {content} {' '.join(tags_list)}"
+        _brain_api("index", {"id": f"{chunk_id}.md", "path": f"{chunk_id}.md", "content": search_text, "brain_id": "wicked-brain"})
+        return chunk_id
+    except Exception:
+        return None
+
+
+def _capture_session_goal(prompt: str, turn_count: int, project: str, session_id: str):
+    """On turns 1-2, save the session goal as WORKING memory via brain API."""
+    if turn_count > 2:
+        return
+    if len(prompt.strip()) < 20:
+        return
+    try:
+        _write_brain_memory(
+            title=f"Session goal (turn {turn_count})",
+            content=prompt[:500],
+            tier="working",
+            tags=["session-goal", "auto-captured"],
+            mem_type="working",
+            importance=5,
+        )
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Turn counter
+# ---------------------------------------------------------------------------
+
+def _increment_turn(state) -> int:
+    """Increment session turn counter, reset turn progress tracking, and return new value."""
+    if state is None:
+        return 0
+    try:
+        new_count = (state.turn_count or 0) + 1
+        # Reset turn progress visibility fields (Issue #323)
+        state.update(
+            turn_count=new_count,
+            turn_start_ts=datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+            turn_tool_count=0,
+        )
+        state.save()
+        return new_count
+    except Exception:
+        return 0
+
+
+# ---------------------------------------------------------------------------
+# Jam suggestion (session-level, hook-local)
+# ---------------------------------------------------------------------------
+
+_JAM_AMBIGUITY_SIGNALS = [
+    "options", "tradeoffs", "trade-off", "should we", "brainstorm",
+    "alternatives", "pros and cons", "compare", "which approach",
+    "what are the", "explore", "think through", "uncertain", "unclear",
+    "not sure", "ideas", "different ways",
+]
+
+
+def _has_ambiguity_signals(prompt: str) -> bool:
+    """Return True if prompt contains explicit ambiguity / exploration signals."""
+    lower = prompt.lower()
+    return any(sig in lower for sig in _JAM_AMBIGUITY_SIGNALS)
+
+
+# Archetypes whose playbook ends in a produces-gate that re-derives through
+# wicked-loom. For these, steering is only actionable if it names the exact
+# `prove.py` one-liner the agent should reach for at the gate phase. Keyed by
+# archetype -> (claim, gate-phase, hard-gate?). Hard gates (incident/migrate/
+# review) require an INDEPENDENT attestation, so they carry --with-attestations.
+# Archetypes absent from this map (explore, triage) have no produces-gate, so
+# no prove hint is emitted for them (silence is correct).
+_PROVE_GATE = {
+    "build":    ("tests-pass",       "review",               False),
+    "specify":  ("criteria-met",     "validate",             False),
+    "decide":   ("adr-recorded",     "record",               False),
+    "ship":     ("rollout-healthy",  "soak",                 False),
+    "review":   ("review-verdict",   "remediate-or-accept",  True),
+    "incident": ("incident-resolved", "resolve",             True),
+    "migrate":  ("rollback-proven",  "cutover",              True),
+}
+
+
+def _prove_hint_for(archetype: str) -> str | None:
+    """Return the concrete `prove:` one-liner for an archetype's produces-gate,
+    or None when the archetype has no gate. Tells the agent exactly how to
+    re-derive (not assert) the produce at the gate phase. Fail-open: any
+    unexpected input yields None rather than raising.
+
+    The verify command is a placeholder (`<verify cmd>`) the agent fills in —
+    e.g. the project's test command for build, a `cat <artifact>` + --verifier
+    for doc-shaped produces. Hard gates append --with-attestations so the gate
+    stays REJECT until an independent evaluator attests.
+    """
+    spec = _PROVE_GATE.get(archetype)
+    if not spec:
+        return None
+    claim, phase, hard = spec
+    line = (
+        f"prove: scripts/qe/prove.py {claim} --by \"<verify cmd>\" "
+        f"--scope {archetype} --phase {phase}"
+    )
+    if hard:
+        line += " --with-attestations"
+    return line
+
+
+def _with_prove_hints(directive: str, archetypes: list[str]) -> str:
+    """Append prove-hint line(s) to a directive for any gated archetypes.
+
+    Dedupes, preserves catalog order, and is a no-op when none of the
+    archetypes have a produces-gate. Fail-open on any error (returns the
+    original directive unchanged)."""
+    try:
+        hints = []
+        seen = set()
+        for a in archetypes:
+            if a in seen:
+                continue
+            seen.add(a)
+            h = _prove_hint_for(a)
+            if h:
+                hints.append(h)
+        if not hints:
+            return directive
+        return directive + "\n" + "\n".join(hints)
+    except Exception:
+        return directive
+
+
+def _build_archetype_directive(prompt: str, intent: str, state=None) -> str | None:
+    """v11 — emit a slim work-shape archetype steering directive.
+
+    Two-tier classification:
+
+    1. **Persisted (LLM)**: when SessionState carries a recent
+       `classified_at` + `archetypes_v11`, prefer that — the model
+       already classified through the wicked-garden:classify skill.
+    2. **Fallback (regex)**: when no persisted classification exists,
+       run archetypes_v11.detect_archetypes() against the prompt
+       directly. If the prompt is non-trivial (intent != simple-edit)
+       AND the regex result is weak (only triage matched), emit a
+       directive asking the model to invoke the classify skill —
+       LLM reasoning beats regex on ambiguous prompts.
+
+    Skips emission when intent is 'simple-edit' (silence is the signal).
+    Fail-open on any error.
+    """
+    if not prompt or not prompt.strip():
+        return None
+    if intent == "simple-edit":
+        return None
+
+    # Tier 1: persisted classification from the classify skill
+    persisted = (getattr(state, "archetypes_v11", None) or []) if state else []
+    if persisted:
+        # Filter triage out unless sole match; emit shape-card from persisted.
+        real = [a for a in persisted if a.get("name") != "triage"]
+        if not real:
+            return None
+        if len(real) == 1 and float(real[0].get("score", 0)) >= 0.7:
+            n = real[0]["name"]
+            s = float(real[0]["score"])
+            base = f"<wg archetype=\"{n}\" score=\"{s:.2f}\" classified=\"llm\" />"
+            return _with_prove_hints(base, [n])
+        shape_lines = [
+            f"  - {a['name']} ({float(a.get('score', 0)):.2f})"
+            for a in real[:3]
+        ]
+        base = (
+            "<wg archetypes classified=\"llm\">\n"
+            + "\n".join(shape_lines)
+            + "\n</wg>"
+        )
+        return _with_prove_hints(base, [a["name"] for a in real[:3]])
+
+    # Tier 2: regex fallback
+    try:
+        from pathlib import Path as _Path
+        import sys as _sys
+        _scripts = _Path(__file__).resolve().parents[1].parent / "scripts"
+        _crew = _scripts / "crew"
+        for p in (_scripts, _crew):
+            if str(p) not in _sys.path:
+                _sys.path.append(str(p))
+        from archetypes_v11 import detect_archetypes, HIGH_CONFIDENCE
+    except Exception:
+        return None
+
+    try:
+        matches = detect_archetypes(prompt)
+    except Exception:
+        return None
+
+    real = [(n, s, e) for (n, s, e) in matches if n != "triage"]
+
+    if not real:
+        # Regex couldn't classify cleanly — ask the model to do it instead.
+        # This is the LLM-classifier opt-in path: the model invokes the
+        # wicked-garden:classify skill, persists the result, and on the
+        # next turn the persisted-tier branch above takes over.
+        return (
+            "<wg classify-due />\n"
+            "Regex classifier could not route this prompt to a v11 archetype. "
+            "Invoke the `wicked-garden:classify` skill to classify with model "
+            "reasoning, then run the chosen archetype's playbook."
+        )
+
+    high = [(n, s, e) for (n, s, e) in real if s >= HIGH_CONFIDENCE]
+    if len(high) == 1 and len(real) == 1:
+        n, s, _ = high[0]
+        base = f"<wg archetype=\"{n}\" score=\"{s:.2f}\" classified=\"regex\" />"
+        return _with_prove_hints(base, [n])
+
+    shape_lines = [f"  - {n} ({s:.2f})" for (n, s, _) in real[:3]]
+    base = (
+        "<wg archetypes classified=\"regex\">\n"
+        + "\n".join(shape_lines)
+        + "\n</wg>"
+    )
+    return _with_prove_hints(base, [n for (n, _s, _e) in real[:3]])
+
+
+def _suggest_jam(prompt: str, state) -> str | None:
+    """Return a jam suggestion string if conditions are met, or None.
+
+    Conditions:
+    1. Prompt contains ambiguity signals
+    2. Prompt does not already reference a jam command
+    3. Hint not shown this session
+
+    Returns the hint string to append, or None if no suggestion should be shown.
+    """
+    if ":jam:" in prompt.lower() or "/jam:" in prompt.lower():
+        return None  # Already using jam — no suggestion needed
+    if not _has_ambiguity_signals(prompt):
+        return None
+    jam_shown = getattr(state, "jam_hint_shown", False) if state else False
+    if jam_shown:
+        return None
+
+    try:
+        if state:
+            state.update(jam_hint_shown=True)
+    except Exception:
+        pass
+    return (
+        "[Suggestion] This prompt involves exploring options or tradeoffs. "
+        "Consider /wicked-garden:jam:quick for fast structured thinking, "
+        "or /wicked-garden:jam:brainstorm for a full multi-perspective session."
+    )
+
+
+# ---------------------------------------------------------------------------
+# Complexity + risk scoring (inline, no API calls, no external imports)
+# ---------------------------------------------------------------------------
+
+_SYNTHESIS_THRESHOLD = 0.40  # complexity >= this OR is_risky → trigger synthesis
+
+_DEEP_WORK_SIGNALS = frozenset({
+    "implement", "architecture", "design", "refactor", "migrate",
+    "integrate", "why does", "how does", "why is", "how do", "how should",
+    "explain", "compare", "analyze", "review", "investigate", "diagnose",
+    "difference between", "best approach", "should i", "what if",
+    "trade-off", "tradeoff", "what happens", "what would",
+})
+
+_RISK_SIGNALS = frozenset({
+    "delete", "drop table", "remove all", "migration", "production", "prod ",
+    "deploy", "breaking change", "credentials", "secret key",
+    "password", "force push", "hard reset",
+})
+# Risk signals that must match as whole words (not substrings)
+_RISK_WORD_SIGNALS = frozenset({"auth token", "api key", "rollback", "purge", "truncate"})
+
+_MULTI_PART_SIGNALS = frozenset({
+    "and also", "additionally", "furthermore", "first,", "second,",
+    "third,", "as well as", "along with",
+})
+
+
+def _score_complexity_and_risk(prompt: str, state) -> tuple[float, bool]:
+    """Fast inline complexity + risk scoring. No external imports, <1ms."""
+    words = prompt.split()
+    word_count = len(words)
+    prompt_lower = prompt.lower()
+
+    complexity = 0.0
+
+    # Length signals (longer = more likely complex)
+    if word_count > 8:  complexity += 0.10
+    if word_count > 25: complexity += 0.10
+    if word_count > 60: complexity += 0.10
+    if word_count > 110: complexity += 0.05
+
+    # Multi-part signals
+    if any(s in prompt_lower for s in _MULTI_PART_SIGNALS): complexity += 0.15
+    if prompt.count("?") > 1: complexity += 0.10
+
+    # Deep work signals (understanding / analysis / design)
+    matches = sum(1 for s in _DEEP_WORK_SIGNALS if s in prompt_lower)
+    complexity += min(matches * 0.15, 0.30)
+
+    # Novelty: prompt topics not in session history → new territory
+    try:
+        session_topics = set(getattr(state, "topics", None) or [])
+        if session_topics:
+            prompt_words = {w.lower() for w in words if len(w) > 4}
+            if not (prompt_words & session_topics):
+                complexity += 0.15  # No overlap = unfamiliar territory
+    except Exception:
+        pass
+
+    # Risk detection (separate from complexity)
+    is_risky = (
+        any(s in prompt_lower for s in _RISK_SIGNALS)
+        or any(s in prompt_lower for s in _RISK_WORD_SIGNALS)
+    )
+
+    return min(complexity, 1.0), is_risky
+
+
+# ---------------------------------------------------------------------------
+# Issue #578 — Context Assembly intent classifier
+#
+# The Context Assembly directive used to fire on every prompt whose complexity
+# score crossed _SYNTHESIS_THRESHOLD, including obviously conversational
+# prompts like "any more feedback?" or "lets do it". Same root cause as #572:
+# the hook fires without a signal Claude cannot already see itself.
+#
+# The classifier below is a pure function — takes a prompt + env mapping and
+# returns (should_emit, reason). It is intentionally conservative: when
+# signals conflict, substantive wins, so a long or technical prompt with a
+# short confirmation prefix still grounds via the directive.
+# ---------------------------------------------------------------------------
+
+# Substantive signals — technical verbs that strongly imply real work.
+_IMPERATIVE_TECHNICAL_VERBS = frozenset({
+    "implement", "fix", "refactor", "build", "design", "trace",
+    "debug", "migrate", "integrate", "deploy", "rollback", "optimize",
+    "profile", "benchmark", "explain how", "analyze", "review",
+    "investigate", "diagnose",
+})
+
+# File-path regex — matches any token that looks like path/to/file.ext where
+# ext is a common code/doc extension. Stdlib re, compiled once at import.
+_FILE_PATH_EXTS = (
+    "py", "ts", "tsx", "js", "jsx", "md", "json", "yaml", "yml",
+    "toml", "sh", "rs", "go", "java", "kt", "rb", "cpp", "c", "h",
+    "hpp", "cs", "swift", "php", "sql", "html", "css", "scss",
+)
+_FILE_PATH_PATTERN = re.compile(
+    r"(?:[\w.\-]+[/\\])+[\w.\-]+\.(?:" + "|".join(_FILE_PATH_EXTS) + r")\b",
+    re.IGNORECASE,
+)
+# Bare-filename regex — catches 'validate_plan.py' or 'README.md' with no
+# separator. Must have a non-trivial stem (>= 2 chars) so we don't match
+# 'a.b' noise. Used in addition to the path pattern above.
+_BARE_FILENAME_PATTERN = re.compile(
+    r"\b[\w\-]{2,}\.(?:" + "|".join(_FILE_PATH_EXTS) + r")\b",
+    re.IGNORECASE,
+)
+
+# Inline backtick or fenced code block
+_CODE_FENCE_OR_BACKTICK = re.compile(r"```|`[^`\n]{2,}`")
+
+
+def _has_file_path(prompt: str) -> bool:
+    """Return True if the prompt contains a file reference.
+
+    Matches either ``path/to/file.ext`` (path + separator) or a bare filename
+    like ``validate_plan.py`` / ``README.md``. Either form is a strong
+    substantive signal — the user is pointing at real code.
+    """
+    if _FILE_PATH_PATTERN.search(prompt):
+        return True
+    return bool(_BARE_FILENAME_PATTERN.search(prompt))
+
+
+def _has_code_markers(prompt: str) -> bool:
+    """Return True if the prompt has a code fence or inline backtick code."""
+    return bool(_CODE_FENCE_OR_BACKTICK.search(prompt))
+
+
+def _has_imperative_technical_verb(prompt_lower: str) -> bool:
+    """Return True if any imperative technical verb appears in the prompt."""
+    return any(verb in prompt_lower for verb in _IMPERATIVE_TECHNICAL_VERBS)
+
+
+# ---------------------------------------------------------------------------
+# Setup gate
+# ---------------------------------------------------------------------------
+
+_GUARD_PASS_PREFIXES = (
+    "/wicked-garden:setup",
+    "/wicked-garden:help",
+    "/setup",
+    "/help",
+)
+
+
+def _check_setup_gate(prompt: str) -> str | None:
+    """Check if wicked-garden setup is needed.
+
+    Returns None if setup is complete (config.json exists with setup_complete=true).
+    Calls sys.exit(2) if config is missing or incomplete — this hard-blocks
+    the prompt and feeds the error message back to the model.
+
+    Always checks config.json on disk — no session state caching.
+    """
+    stripped = prompt.strip().lower()
+
+    # Exemption: let setup and help commands through
+    if stripped.startswith(_GUARD_PASS_PREFIXES):
+        try:
+            from _session import SessionState
+            state = SessionState.load()
+            state.update(setup_in_progress=True)
+        except Exception:
+            pass
+        return None
+
+    # Allow prompts through when setup is actively running — but verify
+    # that setup_in_progress isn't stale from a previous session by
+    # confirming config.json doesn't already have setup_complete=true.
+    try:
+        from _session import SessionState
+        state = SessionState.load()
+        if state.setup_in_progress:
+            config_path = Path.home() / ".something-wicked" / "wicked-garden" / "config.json"
+            config_done = False
+            try:
+                if config_path.exists():
+                    cfg = json.loads(config_path.read_text())
+                    config_done = cfg.get("setup_complete", False)
+            except (json.JSONDecodeError, OSError):
+                pass
+            if config_done:
+                # Config already complete — flag is stale, clear it
+                state.update(setup_in_progress=False)
+            else:
+                # Setup genuinely in progress — let the prompt through
+                return None
+    except Exception:
+        pass
+
+    # Check config.json on disk — the single source of truth for setup status.
+    config_path = Path.home() / ".something-wicked" / "wicked-garden" / "config.json"
+    config_ok = False
+    try:
+        if config_path.exists():
+            config = json.loads(config_path.read_text())
+            config_ok = config.get("setup_complete", False)
+    except (json.JSONDecodeError, OSError):
+        pass
+
+    if not config_ok:
+        print(
+            "wicked-garden requires setup before first use.\n"
+            "Run: /wicked-garden:setup",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+
+    return None
+
+
+def _check_brain_gate(prompt: str) -> None:
+    """Warn if wicked-brain server is not reachable.
+
+    Probes the brain API with a 1s timeout. If unreachable, prints a directive
+    to stderr — this feeds back to the model via the hook error channel but does
+    NOT hard-block (sys.exit(2)) since brain is a server process that may be
+    starting up or temporarily unavailable.
+
+    Exempted on setup/help commands (brain not needed before setup completes).
+    """
+    stripped = prompt.strip().lower()
+    if stripped.startswith(_GUARD_PASS_PREFIXES):
+        return
+
+    try:
+        port = _resolve_brain_port()
+        payload = json.dumps({"action": "stats", "params": {}}).encode("utf-8")
+        import urllib.request
+        req = urllib.request.Request(
+            f"http://localhost:{port}/api",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=1) as _resp:
+            pass  # Brain is running — no action needed
+    except Exception:
+        # Deterministic auto-start before nagging: a stopped server is a
+        # hook-fixable condition, not something to delegate to the model.
+        started = False
+        try:
+            from _brain_port import ensure_server
+            started = ensure_server(wait_secs=2.0)
+        except Exception:
+            pass
+        if not started:
+            print(
+                "[wicked-brain] Brain server is not running on port "
+                f"{_resolve_brain_port()} and auto-start failed.\n"
+                "wicked-garden requires wicked-brain for context assembly and memory.\n"
+                "Brain skills auto-start the server on every call — do NOT skip "
+                "brain usage. Diagnose with: wicked-brain-call --start. "
+                "If not installed: claude plugin install wicked-brain --scope project",
+                file=sys.stderr,
+            )
+
+
+# v11: _assemble_current_chain, _consume_facilitator_reeval, and
+# _consume_phase_start_gate were removed. They referenced deleted scripts
+# (current_chain.py, propose-process skill, phase_start_gate.py) that lived
+# in the v6 universal-pipeline machinery. v11 archetypes handle re-eval
+# inside their own playbooks.
+
+def _check_onboarding_gate(prompt: str) -> str | None:
+    """Check if the current project needs onboarding.
+
+    Returns an onboarding directive string to inject if onboarding is needed,
+    or None if onboarding is complete or cannot be determined.
+
+    Unlike the setup gate, this does NOT hard-block — it returns a directive
+    that gets injected into the system message so the model runs setup.
+    Uses session state set by bootstrap.py to avoid re-checking on every turn.
+    """
+    stripped = prompt.strip().lower()
+
+    # Exemption: setup/help commands handle their own onboarding flow
+    if stripped.startswith(_GUARD_PASS_PREFIXES):
+        return None
+
+    try:
+        from _session import SessionState
+        state = SessionState.load()
+
+        # If setup is in progress, don't block with onboarding directive
+        if state.setup_in_progress:
+            return None
+
+        # If onboarding is already confirmed complete, nothing to do
+        if state.onboarding_complete:
+            return None
+
+        # If bootstrap flagged that onboarding is needed, enforce it
+        if state.needs_onboarding:
+            project = os.environ.get("CLAUDE_PROJECT_NAME") or Path.cwd().name
+            return (
+                f"[Action Required] Project '{project}' has not been onboarded.\n"
+                "You MUST immediately invoke the Skill tool with skill='wicked-garden:setup' "
+                "to launch the interactive onboarding wizard.\n"
+                "Do NOT ask the user for confirmation — invoke the skill now.\n"
+                "Do NOT respond with text first — invoke the skill as your first action."
+            )
+    except Exception:
+        pass  # Fail open — don't block on errors
+
+    return None
+
+
+
+# ---------------------------------------------------------------------------
+# v10 Phase 1 (#813) — intent variable
+# ---------------------------------------------------------------------------
+# The intent variable names what five overlapping classifiers were collectively
+# detecting. Auto-detected on turn 1-2 from existing complexity/risk signals,
+# sticky for the session, overridable via /wicked-garden:intent. Hooks gate
+# directive emission on intent. Design: brainstorms/v10-session-01-intent-and-hook-gating.md.
+
+_INTENT_VALUES = ("simple-edit", "feature", "rigor", "research")
+_AUTO_DETECT_TURN_LIMIT = 2  # auto-detect runs only on turns ≤ this; sticky after
+
+# Crew/rigor command prefixes — invocations that warrant rigor regardless of
+# prompt complexity (answer to brainstorm Q3: rely on auto-detection signals
+# rather than per-command self-declare ceremony).
+_RIGOR_COMMAND_PREFIXES = (
+    "/wicked-garden:crew:",
+    "/wg-issue",
+    "/wg-test",
+)
+
+# Research signal phrases — explanation/analysis prompts that route to research
+# directive even at low complexity.
+_RESEARCH_SIGNALS = (
+    "explain how", "explain why", "why does", "how does", "what is the",
+    "describe the", "walk me through", "analyze", "investigate",
+)
+
+
+def _detect_intent(prompt: str, complexity: float, is_risky: bool, state) -> str:
+    """Auto-detect session intent from prompt + complexity/risk signals.
+
+    Called once per session on turn 1-2. Result is sticky — subsequent turns
+    read state.intent directly. User overrides via /wicked-garden:intent skill
+    set state.intent_explicit=True.
+
+    Detection priority:
+      1. Rigor commands (/wicked-garden:crew:*, etc.) → rigor
+      2. Research signals (explain how, why does, walk me through) → research
+      3. Risk OR complexity ≥ threshold OR technical verb → feature
+      4. Default → simple-edit (conservative; user can /wicked-garden:intent up)
+    """
+    if not prompt or not prompt.strip():
+        return "simple-edit"
+
+    prompt_lower = prompt.lower().strip()
+
+    # 1. Explicit rigor invocations (crew/wg-issue/wg-test commands)
+    if any(prompt_lower.startswith(p) for p in _RIGOR_COMMAND_PREFIXES):
+        return "rigor"
+
+    # 2. Research signals (explanation/analysis intent)
+    if any(s in prompt_lower for s in _RESEARCH_SIGNALS):
+        return "research"
+
+    # 3. Feature signals (risk, complexity, technical verbs)
+    if is_risky or complexity >= _SYNTHESIS_THRESHOLD:
+        return "feature"
+    if _has_imperative_technical_verb(prompt_lower):
+        return "feature"
+    if _has_file_path(prompt) or _has_code_markers(prompt):
+        return "feature"
+
+    # 4. Default conservative classification
+    return "simple-edit"
+
+
+def _ensure_intent_set(prompt: str, state, complexity: float, is_risky: bool) -> str:
+    """Resolve session intent, auto-detecting if not yet set.
+
+    Public entrypoint that callers in main() use to populate
+    ``state.intent`` for a turn. On turn ≤ _AUTO_DETECT_TURN_LIMIT and
+    intent is None → detect via ``_detect_intent``, persist via
+    ``state.update``, return. On later turns or when intent is already
+    set → return existing value. Never overwrites an explicit override.
+
+    Returns the effective intent value (always a string from _INTENT_VALUES).
+    """
+    existing = getattr(state, "intent", None) if state else None
+    if existing in _INTENT_VALUES:
+        return existing
+
+    turn = getattr(state, "turn_count", 0) if state else 0
+    if turn > _AUTO_DETECT_TURN_LIMIT and existing is None:
+        # Past the auto-detect window with no intent set — fall back to
+        # conservative default rather than re-classify mid-session.
+        return "simple-edit"
+
+    detected = _detect_intent(prompt, complexity, is_risky, state)
+    try:
+        if state:
+            state.update(intent=detected, intent_explicit=False)
+    except Exception:
+        pass  # fail open — return value still usable for this turn
+    return detected
+
+
+def _build_intent_directive(intent: str, turn_count: int, explicit: bool, state=None) -> str:
+    """Build the system-reminder directive for a given intent.
+
+    Output rules (brainstorm decision):
+      simple-edit + auto-detect → empty string (silence is the signal)
+      simple-edit + explicit    → bare label only ("user said simple-edit")
+      feature                   → synthesis directive (+ label if explicit)
+      research                  → synthesis directive (+ label if explicit)
+      rigor                     → synthesis directive + chain context (+ label if explicit)
+
+    The label-only-on-explicit rule prevents confirmation-bias drift —
+    auto-detected intent stays invisible to the model so it doesn't
+    second-guess the framework's silent classification.
+    """
+    label = f'<wg intent="{intent}" t={turn_count} />' if explicit else ""
+
+    if intent == "simple-edit":
+        return label  # empty when auto-detected
+
+    # synthesis directive shared by feature / research / rigor
+    directive_lines = [
+        f"[Context Assembly — intent={intent}] Deep context needed before answering.",
+        "BEFORE drafting a response:",
+        "1. Call wicked-brain:query for conceptual grounding ('how does X work', "
+        "'what are the constraints around Y').",
+        "2. Call wicked-brain:search for specific symbols, files, or past decisions. "
+        "Drill into wiki hits with wicked-brain:read depth=2.",
+    ]
+    if intent == "rigor":
+        directive_lines.append(
+            "3. If results cite a wicked-garden:crew project, check its phase and "
+            "active_chain_id before committing to an approach."
+        )
+    directive_lines.append("Only after grounding is complete, answer the original prompt.")
+
+    directive = "\n".join(directive_lines)
+    if label:
+        return f"{label}\n{directive}"
+    return directive
+
+
+# ---------------------------------------------------------------------------
+# WIP recovery after context compaction
+# ---------------------------------------------------------------------------
+
+def _build_wip_recovery_block(session_id: str, project: str) -> str:
+    """Build a WIP recovery block if compaction just happened.
+
+    v6: the v5 compaction-detection path (PressureTracker.was_just_compacted +
+    HistoryCondenser wip_snapshot) was deleted with smaht/v2 in #428. For v6
+    we rely on native in-progress tasks as the sole WIP source — if the task
+    dir is empty we emit nothing. Acceptable per gate4-deletion-manifest.md §5.2
+    ("compaction is rare and facilitator re-evaluate-on-TaskCompleted covers
+    the crew case").
+
+    Returns a formatted markdown block listing in-progress tasks, or an
+    empty string when there's no signal worth showing.
+    """
+    # v6: no compaction-detection; always try to surface native in-progress
+    # tasks. Fail-open to empty string on any error.
+    wip_data = None
+
+    # --- Source 3: Native in-progress tasks (optional, fail gracefully) ---
+    # Reads the same store SubagentStart uses for procedure-bundle lookup.
+    # Routing: WG_DAEMON_ENABLED=false → direct file read (unchanged);
+    #          WG_DAEMON_ENABLED=true  → daemon HTTP with fallback (#596 v8-PR-2).
+    in_progress_tasks = []
+    try:
+        session_id = os.environ.get("CLAUDE_SESSION_ID", "")
+        if session_id:
+            from crew._task_reader import list_in_progress_tasks  # type: ignore[import]
+            in_progress_tasks = list_in_progress_tasks(session_id, limit=5)
+    except Exception:
+        pass  # task query is best-effort
+
+    # --- Format recovery block (budget: <1000 chars) ---
+    # v6: only surface in-progress tasks. The v5 ticket-rail fields
+    # (current_task, decisions, file_scope, active_constraints, open_questions)
+    # are gone. If nothing is in-progress, emit nothing.
+    if not in_progress_tasks:
+        _log("smaht", "debug", "wip_recovery.empty")
+        return ""
+
+    parts = ["## [Recovery] Work in progress\n"]
+    parts.append("### In-Progress Tasks")
+    for task in in_progress_tasks:
+        parts.append(f"- {task[:80]}")
+    parts.append("\n**IMPORTANT**: Review before proceeding. Do NOT repeat completed work.")
+
+    block = "\n".join(parts)
+
+    # Enforce budget: truncate to ~1000 chars if needed
+    if len(block) > 1000:
+        block = block[:997] + "..."
+
+    _log("smaht", "debug", "wip_recovery.done", detail={"chars": len(block)})
+    return block
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    _t0 = time.monotonic()
+    _log("smaht", "debug", "hook.start")
+
+    try:
+        raw = sys.stdin.read()
+        input_data = json.loads(raw) if raw.strip() else {}
+    except Exception:
+        print(json.dumps({"continue": True}))
+        return
+
+    prompt = input_data.get("prompt", "")
+    session_id = input_data.get("session_id", os.environ.get("CLAUDE_SESSION_ID", "default"))
+    project = os.environ.get("CLAUDE_PROJECT_NAME") or Path.cwd().name
+
+    if not prompt.strip():
+        print(json.dumps({"continue": True}))
+        return
+
+    # Setup gate — hard-block (sys.exit(2)) if no config.
+    # MUST run before HOT continuations so setup can never be bypassed.
+    _check_setup_gate(prompt)
+
+    # Brain gate — soft directive if brain server is not reachable.
+    # Runs after setup gate (brain irrelevant before setup completes).
+    # Does NOT hard-block — brain server may be starting up; user can start it.
+    _check_brain_gate(prompt)
+
+    # Onboarding gate — inject directive if project hasn't been onboarded.
+    # Checked after setup gate but before HOT path so continuations during
+    # an active setup wizard ("yes", "ok") still pass through quickly.
+    onboarding_directive = _check_onboarding_gate(prompt)
+
+    # Issue #572: drain the wicked-bus cursor BEFORE the re-eval check so the
+    # 41k+ lag clears and stale subscriptions don't accumulate further. The
+    # drain is fire-and-forget (events discarded, cursor advanced); the re-eval
+    # signal still comes from task_completed.py's debounced flag, not the bus.
+    # Wrapped in try/except so a bus failure can never break prompt submission.
+    try:
+        _drain_bus_cursor()
+    except Exception:
+        pass
+
+    # v6 Gate 3 (#428) — facilitator re-evaluation directive.
+    # v11: legacy facilitator re-eval + phase-start-gate consumers removed.
+    # Those were tied to the v6 universal pipeline (propose-process + the
+    # phase_start_gate.py script, both deleted in v11). v11 archetypes own
+    # their own checkpoint cadence in their playbooks.
+    facilitator_reeval_directive = None
+    phase_start_gate_directive = None
+
+    # ---------------------------------------------------------------------------
+    # HOT fast-exit: known continuation tokens bypass all imports and any
+    # downstream classification. Keeps HOT path p95 well under 100ms SLO.
+    # These words carry no new intent — there is nothing for context assembly
+    # to add beyond what is already in the conversation window.
+    #
+    # v6 note: the v5 CONTINUATION_PATTERNS in scripts/smaht/v2/router.py was
+    # deleted in #428. This in-hook fast-exit is now the sole continuation
+    # detector — it's just a set membership check, no regex needed.
+    # ---------------------------------------------------------------------------
+    _HOT_CONTINUATIONS = frozenset({
+        "yes", "ok", "okay", "sure", "yep", "yup",
+        "continue", "proceed", "go", "go ahead", "do it",
+        "lgtm", "looks good", "approved", "approve",
+        "no", "nope", "cancel", "stop", "skip",
+        "next", "done",
+    })
+    if prompt.strip().lower() in _HOT_CONTINUATIONS:
+        # v6: no history condenser to update. The HOT path is a pure no-op
+        # bypass — session counter increment still happens via the normal
+        # path for non-continuation turns.
+
+        # Even on HOT path, inject onboarding directive + facilitator re-eval
+        # directive so the gate + re-eval can never be bypassed via continuation
+        # tokens. Re-eval must fire before the user's acknowledgement drives
+        # the next step on a facilitator-owned chain.
+        hot_parts = []
+        if facilitator_reeval_directive:
+            hot_parts.append(facilitator_reeval_directive)
+        if phase_start_gate_directive:
+            hot_parts.append(phase_start_gate_directive)
+        if onboarding_directive:
+            hot_parts.append(onboarding_directive)
+        if hot_parts:
+            print(json.dumps({
+                "hookSpecificOutput": {
+                    "hookEventName": "UserPromptSubmit",
+                    "additionalContext": "\n\n".join(hot_parts),
+                },
+                "continue": True,
+            }))
+        else:
+            print(json.dumps({"continue": True}))
+        return
+
+    try:
+        from _session import SessionState
+        state = SessionState.load()
+    except Exception:
+        state = None
+
+    turn_count = _increment_turn(state)
+
+    # Session goal capture on turns 1-2
+    _capture_session_goal(prompt, turn_count, project, session_id)
+
+    # Complexity + risk gate — inject a deep-context pull directive for complex/risky prompts.
+    # v6: the v5 Router + Orchestrator pre-fetch were deleted in #428. Classification
+    # is an inline heuristic; v6.3.6 retired the wicked-garden:smaht:synthesize skill
+    # and replaced it with a directive pointing at wicked-brain directly.
+    # v10 Phase 1 (#813): replace the legacy 5-classifier cascade
+    # (complexity scorer → context-assembly classifier → near-HOT guard →
+    # synthesis early-return) with a single intent variable. Intent gates
+    # directive emission downstream — see _ensure_intent_set + _build_intent_directive.
+    if not onboarding_directive:
+        complexity, is_risky = _score_complexity_and_risk(prompt, state)
+        intent = _ensure_intent_set(prompt, state, complexity, is_risky)
+        _log("prompt", "debug", "intent.resolved",
+             detail={
+                 "intent": intent,
+                 "explicit": bool(getattr(state, "intent_explicit", False)),
+                 "complexity": round(complexity, 2),
+                 "risk": is_risky,
+                 "turn": turn_count,
+             })
+
+    try:
+        # --- v10 Phase 1 (#813): intent-driven directive ---
+        # The intent variable resolved earlier (or "simple-edit" when this
+        # block runs from the onboarding-pending branch where no intent was
+        # computed) drives directive emission. Auto-detected simple-edit
+        # turns produce an empty directive; feature/research/rigor produce
+        # the synthesis directive. Explicit overrides additionally echo a
+        # bare label so the model knows the user steered the framework.
+        _intent = getattr(state, "intent", None) if state else None
+        _intent_explicit = bool(getattr(state, "intent_explicit", False)) if state else False
+        intent_directive = _build_intent_directive(
+            _intent or "simple-edit", turn_count, _intent_explicit, state
+        )
+
+        # WIP recovery: surface native in-progress tasks (v5 ticket rail gone)
+        wip_block = _build_wip_recovery_block(session_id, project)
+
+        # Build output: single <system-reminder> block with all context parts
+        all_parts = []
+
+        # v6 Gate 3 (#428): facilitator re-evaluation directive has highest
+        # priority — a completed facilitator-owned task must re-plan before
+        # the model addresses the user's prompt.
+        if facilitator_reeval_directive:
+            all_parts.append(facilitator_reeval_directive)
+
+        # AC-11: phase-start gate directive — fires when a phase-transition
+        # event was detected and material changes exist since last re-eval.
+        if phase_start_gate_directive:
+            all_parts.append(phase_start_gate_directive)
+
+        # WIP recovery block goes first so it's the first thing the model sees
+        if wip_block:
+            all_parts.append(wip_block)
+
+        # Onboarding directive goes next for high priority
+        if onboarding_directive:
+            all_parts.append(onboarding_directive)
+
+        # Intent directive (may be empty for auto-detected simple-edit — that
+        # is the v10 win: silence is a signal that the turn is simple).
+        if intent_directive:
+            all_parts.append(intent_directive)
+
+        # v11: work-shape archetype steering. Skips on simple-edit per the
+        # silence-is-the-signal convention. When the prompt routes to a
+        # specific archetype (build / migrate / incident / specify / ...),
+        # emits a slim tag so the agent knows the work shape it's in.
+        archetype_directive = _build_archetype_directive(
+            prompt, _intent or "simple-edit", state=state,
+        )
+        if archetype_directive:
+            all_parts.append(archetype_directive)
+
+        # NOTE (v9.2.11): the periodic [Memory] checkpoint nudge that fired
+        # every 10 turns was removed. It surfaced on every prompt submit at
+        # turns 10, 20, 30 ... regardless of whether the session had produced
+        # anything worth checkpointing — exactly the false-urgency anti-
+        # pattern the v9.2.6 "silent contract drift" wiki article warns
+        # against. CLAUDE.md tells Claude how to use wicked-brain:memory; the
+        # session-teardown agent handles end-of-session synthesis. A turn-
+        # counter timer added no signal.
+
+        # Jam suggestion: when ambiguity signals present
+        jam_hint = _suggest_jam(prompt, state)
+        if jam_hint:
+            all_parts.append(jam_hint)
+
+        # (Prompt-time discovery tips retired — ambient suggestions trained the
+        # agent to ignore the channel; claim-time sentinel signals replaced them.)
+
+        # If nothing material to inject (simple-edit, no WIP, no onboarding,
+        # no hints), suppress the entire <system-reminder> block — this is
+        # the keystone "improves-me" win: silent turns stay silent.
+        if not all_parts:
+            print(json.dumps({"continue": True}))
+            return
+
+        merged_context = f"<system-reminder>\n{chr(10).join(all_parts)}\n</system-reminder>"
+
+        _log("smaht", "debug", "prompt.intent_directive",
+             detail={"intent": _intent, "explicit": _intent_explicit, "turn": turn_count,
+                     "directive_bytes": len(intent_directive.encode("utf-8"))})
+
+        output = {
+            "hookSpecificOutput": {
+                "hookEventName": "UserPromptSubmit",
+                "additionalContext": merged_context,
+            },
+            "continue": True,
+        }
+        _log("smaht", "debug", "hook.end", ms=int((time.monotonic() - _t0) * 1000))
+        print(json.dumps(output))
+
+    except Exception as e:
+        print(f"[wicked-garden] prompt_submit error: {e}", file=sys.stderr)
+        print(json.dumps({"continue": True}))
+
+
+if __name__ == "__main__":
+    main()