@jaguilar87/gaia-ops 4.4.0 → 4.7.2

package/hooks/post_tool_use.py

@@ -18,8 +18,6 @@ sys.path.insert(0, str(Path(__file__).parent))
 
 from modules.core.paths import get_logs_dir
 from adapters.claude_code import ClaudeCodeAdapter
-from modules.core.stdin import has_stdin_data
-from adapters.utils import warn_if_dual_channel
 from modules.core.hook_entry import run_hook
 
 # Configure logging
@@ -48,79 +46,9 @@ def _handle_post_tool_use(event) -> None:
     sys.exit(response.exit_code)
 
 
-# ============================================================================
-# Backward-compatible API for direct callers (e.g. --test mode)
-# ============================================================================
-
-def post_tool_use_hook(
-    tool_name: str,
-    parameters: dict,
-    result: object,
-    duration: float,
-    success: bool = True,
-) -> None:
-    """Post-tool use hook: audit + event detection + context update.
-
-    Backward-compatible entry point that calls the same modules as the adapter.
-    """
-    import time
-    from modules.core.state import get_hook_state, clear_hook_state
-    from modules.audit.logger import log_execution
-    from modules.audit.event_detector import detect_critical_event
-    from modules.session.session_context_writer import SessionContextWriter
-    from modules.security.approval_grants import check_approval_grant, confirm_grant
-
-    try:
-        pre_state = get_hook_state()
-        tier = pre_state.tier if pre_state else "unknown"
-
-        computed_duration = duration
-        if pre_state and pre_state.start_time_epoch > 0:
-            computed_duration = time.time() - pre_state.start_time_epoch
-
-        log_execution(
-            tool_name=tool_name,
-            parameters=parameters,
-            result=result,
-            duration=computed_duration,
-            exit_code=0 if success else 1,
-            tier=tier,
-        )
-
-        if tool_name == "Bash" and success:
-            command = parameters.get("command", "")
-            if command:
-                grant = check_approval_grant(command)
-                if grant is not None and not grant.confirmed:
-                    confirm_grant(command)
-                    logger.info(
-                        "T3 grant confirmed post-execution: %s", command[:80],
-                    )
-
-        events = detect_critical_event(tool_name, parameters, result, success)
-        if events:
-            writer = SessionContextWriter()
-            for event in events:
-                writer.update_context(event.to_dict())
-
-        clear_hook_state()
-        logger.debug("Post-hook completed for %s", tool_name)
-
-    except Exception as e:
-        logger.error("Error in post_tool_use_hook: %s", e, exc_info=True)
-
-
 # ============================================================================
 # STDIN HANDLER (Claude Code integration)
 # ============================================================================
 
 if __name__ == "__main__":
-    if len(sys.argv) > 1 and sys.argv[1] == "--test":
-        post_tool_use_hook(
-            "bash", {"command": "kubectl get pods"},
-            "pod/test-pod   1/1   Running   0   1m", 0.5, True,
-        )
-        print(f"Test completed. Check {get_logs_dir()} for audit logs")
-        sys.exit(0)
-
     run_hook(_handle_post_tool_use, hook_name="post_tool_use")

package/hooks/pre_tool_use.py

@@ -11,6 +11,7 @@ Architecture:
 - All business logic lives in ClaudeCodeAdapter.adapt_pre_tool_use()
 - This file is stdin/stdout glue only
 """
+from __future__ import annotations
 
 import sys
 import json
@@ -47,20 +48,10 @@ logger = logging.getLogger(__name__)
 from modules.tools.bash_validator import BashValidator
 from modules.tools.task_validator import TaskValidator, AVAILABLE_AGENTS, META_AGENTS
 from modules.security.prompt_validator import classify_resume_prompt
-from modules.context.context_injector import inject_project_context, build_project_context
-from modules.session.session_event_injector import inject_session_events, build_session_events
+from modules.context.context_injector import build_project_context
+from modules.session.session_event_injector import build_session_events
 from modules.core.state import create_pre_hook_state, save_hook_state
-from modules.security.approval_constants import (
-    NONCE_APPROVAL_PREFIX,
-    NONCE_APPROVAL_PATTERN,
-)
-from modules.security.approval_messages import (
-    build_activation_failed_message,
-    build_deprecated_approval_message,
-    build_invalid_nonce_message,
-)
 from modules.security.approval_grants import (
-    activate_pending_approval,
     cleanup_expired_grants,
 )
 
@@ -74,16 +65,6 @@ def _classify_resume_prompt(prompt: str) -> str:
     return classify_resume_prompt(prompt)
 
 
-def _inject_project_context(parameters: dict) -> dict:
-    """Inject project context. Delegates to modules.context.context_injector."""
-    return inject_project_context(parameters, PROJECT_AGENTS, _HOOKS_DIR)
-
-
-def _inject_session_events(parameters: dict) -> dict:
-    """Inject session events. Delegates to modules.session.session_event_injector."""
-    return inject_session_events(parameters, PROJECT_AGENTS)
-
-
 def pre_tool_use_hook(tool_name: str, parameters: dict) -> str | dict | None:
     """
     Pre-tool use hook implementation (backward-compatible API).
@@ -137,24 +118,13 @@ def _handle_bash(tool_name: str, parameters: dict) -> str | dict | None:
     result = validator.validate(command)
 
     if not result.allowed:
-        from modules.core.plugin_mode import is_ops_mode
         logger.warning(f"BLOCKED: {command[:100]} - {result.reason}")
 
-        # Security mode: delegate to native Claude Code approval
-        if not is_ops_mode():
-            reason_line = result.reason.split('\n')[0] if result.reason else f"T3 operation: {command[:80]}"
-            logger.info(f"SECURITY MODE: returning 'ask' for T3: {command[:80]}")
-            return {
-                "hookSpecificOutput": {
-                    "hookEventName": "PreToolUse",
-                    "permissionDecision": "ask",
-                    "permissionDecisionReason": f"[{result.tier}] {reason_line}",
-                }
-            }
-
-        # Ops mode: block with nonce
+        # Structured response from bash_validator (ask or deny)
         if result.block_response is not None:
             return result.block_response
+
+        # Permanently blocked (no structured response) — hard block (exit 2)
         return _format_blocked_message(result)
 
     effective_command = result.modified_input.get("command", command) if result.modified_input else command
@@ -185,8 +155,9 @@ def _handle_task(tool_name: str, parameters: dict) -> str | dict | None:
     """
     Handle Task/Agent tool validation for new task dispatches.
 
-    Uses additionalContext (Phase 2) instead of prompt mutation.
-    Validation runs against the original prompt, eliminating T3 false positives.
+    Context is built here and cached for SubagentStart to forward to the
+    subagent.  PreToolUse no longer returns additionalContext (that would
+    inject it into the orchestrator, not the subagent).
     """
     context_text, _telemetry = build_project_context(parameters, PROJECT_AGENTS, _HOOKS_DIR)
     events_text = build_session_events(parameters, PROJECT_AGENTS)
@@ -210,17 +181,31 @@ def _handle_task(tool_name: str, parameters: dict) -> str | dict | None:
 
     logger.info(f"ALLOWED Task: {result.agent_name}")
 
+    # Cache context for SubagentStart to pick up and forward to the subagent.
     additional = "\n".join(filter(None, [context_text, events_text]))
+
+    # Fallback: if build_project_context returned None because the
+    # orchestrator already embedded context in the prompt (dedup guard),
+    # extract the embedded context so SubagentStart can still inject it.
+    if not additional:
+        prompt = parameters.get("prompt", "")
+        marker = "# Project Context"
+        if marker in prompt:
+            idx = prompt.index(marker)
+            additional = prompt[idx:]
+            logger.info(
+                "Extracted embedded context from prompt for caching "
+                "(len=%d, agent=%s)",
+                len(additional), result.agent_name,
+            )
+
     if additional:
-        logger.info(f"Returning additionalContext for {result.agent_name} (context injected)")
-        return {
-            "hookSpecificOutput": {
-                "hookEventName": "PreToolUse",
-                "permissionDecision": "allow",
-                "permissionDecisionReason": f"Context injected for {result.agent_name}",
-                "additionalContext": additional,
-            }
-        }
+        from adapters.claude_code import ClaudeCodeAdapter
+        adapter = ClaudeCodeAdapter()
+        session_id = parameters.get("session_id", "") or "unknown"
+        agent_type = result.agent_name or "unknown"
+        adapter._cache_context_for_subagent(session_id, agent_type, additional)
+        logger.info(f"Cached context for SubagentStart: agent={agent_type}")
 
     return None
 
@@ -229,8 +214,9 @@ def _handle_send_message(tool_name: str, parameters: dict) -> str | None:
     """
     Handle SendMessage tool validation for agent resumption.
 
-    Validates agent ID format and message content, then runs nonce
-    approval checks. Does NOT inject project context (it's a resume).
+    Validates agent ID format and message content. Does NOT inject
+    project context (it's a resume). Nonce relay is no longer processed
+    here -- approval grants are activated by the UserPromptSubmit hook.
 
     Returns:
         None: allowed (no modification)
@@ -265,17 +251,13 @@ def _handle_send_message(tool_name: str, parameters: dict) -> str | None:
 
     logger.info(f"SENDMESSAGE: Resuming agent {agent_id}")
 
-    approval_error, has_approval = _handle_resume_approval(agent_id, message)
-    if approval_error:
-        return approval_error
-
     state = create_pre_hook_state(
         tool_name=tool_name,
         command=f"SendMessage:{agent_id}",
         tier="T0",
         allowed=True,
         is_t3=False,
-        has_approval=has_approval,
+        has_approval=False,
     )
     save_hook_state(state)
 
@@ -283,53 +265,6 @@ def _handle_send_message(tool_name: str, parameters: dict) -> str | None:
     return None
 
 
-def _handle_resume_approval(resume_id: str, prompt: str) -> tuple[str | None, bool]:
-    """Process nonce approval indicators for Task resume."""
-    classification = _classify_resume_prompt(prompt)
-
-    if classification == "nonce":
-        nonce = NONCE_APPROVAL_PATTERN.search(prompt).group(1)
-        activation = activate_pending_approval(nonce)
-        status_text = getattr(activation.status, "value", str(activation.status))
-        if activation.success:
-            grant_path = activation.grant_path
-            grant_name = grant_path.name if grant_path else "<unknown>"
-            logger.info(
-                "Nonce approval activated for resume %s: nonce=%s, file=%s",
-                resume_id,
-                nonce,
-                grant_name,
-            )
-            return None, True
-
-        logger.warning(
-            "Denied resume %s: nonce approval activation failed for nonce=%s "
-            "(status=%s, reason=%s)",
-            resume_id,
-            nonce,
-            status_text,
-            activation.reason,
-        )
-        return build_activation_failed_message(nonce, status_text, activation.reason), False
-
-    if classification == "malformed_nonce":
-        logger.warning(
-            "Denied resume %s: malformed nonce approval token in prompt='%s'",
-            resume_id,
-            prompt[:120],
-        )
-        return build_invalid_nonce_message(), False
-
-    if classification == "deprecated":
-        logger.warning(
-            "Denied resume %s: deprecated legacy approval phrase detected",
-            resume_id,
-        )
-        return build_deprecated_approval_message(), False
-
-    return None, False
-
-
 def _format_blocked_message(result) -> str:
     """Format blocked command message. Delegates to blocked_message_formatter."""
     from modules.security.blocked_message_formatter import format_blocked_message
@@ -413,10 +348,15 @@ if __name__ == "__main__":
 
             if isinstance(response.output, dict) and response.output:
                 hook_output = response.output.get("hookSpecificOutput", {})
-                if hook_output.get("permissionDecision") in ("block", "deny"):
+                decision = hook_output.get("permissionDecision")
+                if decision in ("block", "deny"):
                     reason = hook_output.get("permissionDecisionReason", "Command blocked by hook policy")
                     summary = reason.split('\n')[0]
                     print(f"BLOCKED: {summary}", file=sys.stderr)
+                elif decision == "ask":
+                    reason = hook_output.get("permissionDecisionReason", "")
+                    summary = reason.split('\n')[0]
+                    print(f"T3: {summary}", file=sys.stderr)
                 print(json.dumps(response.output))
                 sys.exit(response.exit_code)
             elif isinstance(response.output, str) and response.output:

package/hooks/session_start.py

@@ -31,8 +31,10 @@ if __name__ == "__main__":
     try:
         sys.stdin.read()
 
-        # First-time setup: create project permissions if needed
-        setup_message = run_first_time_setup()
+        # First-time setup: create project permissions if needed.
+        # mark_done=False so UserPromptSubmit can detect first-run
+        # and show the welcome message before marking initialized.
+        setup_message = run_first_time_setup(mark_done=False)
         if setup_message:
             logger.info("First-time setup: %s", setup_message)
 

package/hooks/subagent_start.py

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
-"""SubagentStart hook — logs agent dispatch and records skill snapshots.
-Context injection is handled exclusively by PreToolUse (Agent matcher)."""
+"""SubagentStart hook — logs agent dispatch, records skill snapshots,
+and forwards cached project context into the subagent.
+
+PreToolUse:Agent builds and caches the context; this hook reads the
+cache and returns it as additionalContext so it reaches the subagent
+(not the orchestrator)."""
 
 import sys
 import json

package/hooks/subagent_stop.py

@@ -32,8 +32,6 @@ sys.path.insert(0, str(Path(__file__).parent))
 
 # Adapter layer
 from adapters.claude_code import ClaudeCodeAdapter
-from modules.core.stdin import has_stdin_data
-from adapters.utils import warn_if_dual_channel
 from modules.core.hook_entry import run_hook
 
 # Configure structured logging with file handler
@@ -62,7 +60,6 @@ logger = logging.getLogger(__name__)
 from modules.agents.contract_validator import (
     extract_commands_from_evidence,
     extract_exit_code_from_output,
-    extract_plan_status_from_output,
     parse_contract,
     requires_consolidation_report,
     validate as validate_contract,
@@ -75,7 +72,7 @@ from modules.agents.response_contract import (
 from modules.agents.task_info_builder import build_task_info_from_hook_data
 from modules.agents.transcript_reader import read_transcript
 from modules.audit.workflow_auditor import audit as audit_workflow, signal_gaia_analysis
-from modules.audit.workflow_recorder import record as record_workflow, get_workflow_memory_dir
+from modules.audit.workflow_recorder import record as record_workflow
 from modules.context.context_writer import process_context_updates
 from modules.memory.episode_writer import write as write_episode
 from modules.security.approval_cleanup import cleanup as cleanup_approval
@@ -83,18 +80,9 @@ from modules.session.session_manager import get_or_create_session_id
 
 _extract_commands_from_evidence = extract_commands_from_evidence
 _extract_exit_code_from_output = extract_exit_code_from_output
-_extract_plan_status_from_output = extract_plan_status_from_output
-_requires_consolidation_report = requires_consolidation_report
 _read_transcript = read_transcript
-_consume_approval_file = cleanup_approval
 _process_context_updates = process_context_updates
 
-# Backward-compatible aliases for old function names used in tests
-capture_episodic_memory = write_episode
-detect_anomalies = audit_workflow
-capture_workflow_metrics = record_workflow
-consume_approval_file = cleanup_approval
-
 
 def _build_task_info_from_hook_data(
     hook_data: Dict[str, Any],

package/hooks/user_prompt_submit.py

@@ -24,39 +24,101 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 
+def _extract_user_prompt(raw_input: str) -> str:
+    """Extract user prompt text from stdin event.
+
+    The UserPromptSubmit event is JSON with the user's message.
+    Try known field names; return empty string if extraction fails.
+    """
+    try:
+        event = json.loads(raw_input)
+        # Try known field names from Claude Code hook events
+        for field in ("user_message", "prompt", "message", "content"):
+            if field in event and isinstance(event[field], str):
+                return event[field]
+        # Check nested hookEventInput
+        hook_input = event.get("hookEventInput", {})
+        if isinstance(hook_input, dict):
+            for field in ("user_message", "prompt", "message", "content"):
+                if field in hook_input and isinstance(hook_input[field], str):
+                    return hook_input[field]
+    except (json.JSONDecodeError, TypeError, AttributeError):
+        pass
+    return ""
+
+
+def _build_routing_recommendation(prompt_text: str) -> str:
+    """Run surface classification and format as a routing recommendation block.
+
+    Returns empty string if classification fails or produces no active surfaces.
+    This is advisory — never raises exceptions.
+    """
+    try:
+        # Import surface_router from tools/context
+        tools_dir = Path(__file__).resolve().parent.parent / "tools" / "context"
+        if str(tools_dir) not in sys.path:
+            sys.path.insert(0, str(tools_dir))
+
+        from surface_router import classify_surfaces
+
+        routing = classify_surfaces(prompt_text)
+
+        active_surfaces = routing.get("active_surfaces", [])
+        if not active_surfaces:
+            logger.info("Surface routing: no active surfaces for prompt")
+            return ""
+
+        agents = routing.get("recommended_agents", [])
+        dispatch_mode = routing.get("dispatch_mode", "single_surface")
+        confidence = routing.get("confidence", 0.0)
+        matched_signals = routing.get("matched_signals", {})
+
+        # Flatten matched signals into a single list for display
+        all_signals = []
+        for surface_signals in matched_signals.values():
+            all_signals.extend(surface_signals)
+
+        lines = [
+            "\n\n## Surface Routing Recommendation",
+            f"- Recommended agents: {agents}",
+            f"- Dispatch mode: {dispatch_mode}",
+            f"- Confidence: {confidence}",
+            f"- Matched signals: {json.dumps(all_signals)}",
+        ]
+
+        logger.info(
+            "Surface routing: agents=%s mode=%s confidence=%.2f signals=%s",
+            agents, dispatch_mode, confidence, all_signals,
+        )
+        return "\n".join(lines)
+
+    except Exception as e:
+        logger.warning("Surface routing failed (advisory, skipping): %s", e)
+        return ""
+
+
 def _build_welcome(mode: str) -> str:
-    """Build first-run welcome message for the user."""
+    """Build first-run welcome message for the user.
+
+    This message is injected as additionalContext so Claude receives it,
+    not the user directly.  The framing explains WHY the user needs to
+    know — Claude should naturally relay it because it is actionable
+    and the user cannot use the plugin fully without restarting.
+    """
     plugin_name = f"GAIA {'Ops' if mode == 'ops' else 'Security'}"
-    repo_url = "https://github.com/metraton/gaia-ops"
-    tiers_info = (
-        "Security tiers: T0 (read-only, auto-allowed) → T1 (validation) → "
-        "T2 (simulation) → T3 (state change, requires approval) → "
-        "T3-blocked (irreversible, permanently blocked)."
-    )
-    learn_more = (
-        f"To learn more about security tiers, ask: 'explain the security tiers'. "
-        f"Docs and source: {repo_url}"
-    )
 
-    if mode == "ops":
-        return (
-            f"FIRST-TIME SETUP: {plugin_name} is now active. "
-            "Your permissions have been configured to allow GAIA to manage "
-            "security classification and agent dispatch. "
-            "To activate these permissions, close this session and reopen Claude Code. "
-            "After that, GAIA will handle command classification automatically. "
-            f"{tiers_info} "
-            f"{learn_more} "
-            "You must tell the user this message exactly."
-        )
     return (
-        f"FIRST-TIME SETUP: {plugin_name} is now active. "
-        "Your permissions have been configured to delegate security decisions to GAIA. "
-        "To activate these permissions, close this session and reopen Claude Code. "
-        "After that, GAIA Security will classify every command by risk automatically. "
-        f"{tiers_info} "
-        f"{learn_more} "
-        "You must tell the user this message exactly."
+        f"{plugin_name} was just installed for the first time in this project. "
+        f"The plugin detected the installation and configured security permissions, "
+        f"but these permissions only take effect after restarting Claude Code. "
+        f"Until the user closes this session and reopens Claude Code, "
+        f"{plugin_name} cannot protect their commands — destructive operations "
+        f"will not be blocked and mutative operations will not require approval. "
+        f"The user needs to know this because they just installed {plugin_name} "
+        f"expecting it to work, but it will not be active until they restart. "
+        f"Tell the user that {plugin_name} is installed, that they need to close "
+        f"and reopen Claude Code to activate it, and that until they do, "
+        f"security protections are not active."
     )
 
 
@@ -65,20 +127,40 @@ if __name__ == "__main__":
         sys.exit(0)
 
     try:
-        sys.stdin.read()
-        from modules.core.plugin_setup import is_first_run
+        raw_input = sys.stdin.read()
+
+        # Check first-run BEFORE setup (SessionStart does setup with
+        # mark_done=False so the marker doesn't exist yet on first run).
+        from modules.core.plugin_setup import is_first_run, mark_initialized
         first_run = is_first_run()
 
-        # Ensure registry + permissions exist
-        setup_msg = run_first_time_setup()
+        # Ensure registry + permissions exist (idempotent, no mark).
+        setup_msg = run_first_time_setup(mark_done=False)
         identity = build_identity()
         mode = "ops" if "Orchestrator" in identity else "security"
 
-        # First-time welcome: tell user what happened and what to do
-        if first_run and setup_msg:
+        # First-time welcome: the marker does not exist yet because
+        # neither SessionStart nor this call marked it.
+        if first_run:
             welcome = _build_welcome(mode)
-            identity += f"\n\n{welcome}"
-            logger.info("First-run welcome appended for %s mode", mode)
+            identity = f"{welcome}\n\n{identity}"
+            mark_initialized()  # Mark AFTER building the welcome
+            logger.info("First-run welcome prepended for %s mode", mode)
+
+        # Append deterministic surface routing recommendation (ops mode only)
+        if mode == "ops":
+            prompt_text = _extract_user_prompt(raw_input)
+
+            # NOTE: Approval activation moved to ElicitationResult hook.
+            # AskUserQuestion responses trigger ElicitationResult, not
+            # UserPromptSubmit, so approval detection lives there now.
+
+            if prompt_text:
+                routing_block = _build_routing_recommendation(prompt_text)
+                if routing_block:
+                    identity = identity + routing_block
+            else:
+                logger.info("Could not extract user prompt from stdin, skipping routing")
 
         logger.info("Identity injected: %s mode (%d chars)", mode, len(identity))
 

package/index.js

@@ -56,7 +56,7 @@ export function getCommandPath(commandName) {
 
 /**
  * Get absolute path to a template
- * @param {string} templateName - Name of the template (e.g., 'settings.template.json')
+ * @param {string} templateName - Name of the template (e.g., 'governance.template.md')
  * @returns {string} Absolute path to template file
  */
 export function getTemplatePath(templateName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaguilar87/gaia-ops",
-  "version": "4.4.0",
+  "version": "4.7.2",
   "description": "Multi-agent orchestration system for Claude Code - DevOps automation toolkit",
   "main": "index.js",
   "type": "module",
@@ -53,6 +53,8 @@
     "config/",
     "speckit/",
     "skills/",
+    "dist/",
+    "git-hooks/",
     "README.md",
     "INSTALL.md",
     "CHANGELOG.md",
@@ -77,11 +79,11 @@
     "pre-publish:dry": "node bin/pre-publish-validate.js --dry-run",
     "pre-publish:validate": "node bin/pre-publish-validate.js --validate-only",
     "prepack": "npm run clean",
-    "prepublishOnly": "npm run clean",
+    "prepublishOnly": "npm run build:plugins && node bin/pre-publish-validate.js",
     "postinstall": "node bin/gaia-update.js",
     "preuninstall": "node bin/gaia-cleanup.js"
   },
-  "_postinstall_note": "postinstall: CLAUDE.md overwritten (static), settings.json merged (custom rules preserved)",
+  "_postinstall_note": "postinstall: settings.json replaced (hooks only), permissions merged into settings.local.json (union, user config preserved)",
   "dependencies": {
     "chalk": "^5.3.0",
     "ora": "^7.0.1",

package/skills/README.md

@@ -8,7 +8,6 @@ Skills are knowledge modules that extend agent capabilities. They use Claude Cod
 .claude/skills/
 ├── agent-protocol/        # json:contract format, state machine, repair flow
 ├── agent-response/        # Orchestrator: interpret agent json:contract responses
-├── project-dispatch/      # Orchestrator: agent table and dispatch rules
 ├── security-tiers/        # T0-T3 classification
 │   └── reference.md
 ├── investigation/         # Diagnosis methodology and pattern analysis
@@ -28,7 +27,7 @@ Skills are knowledge modules that extend agent capabilities. They use Claude Cod
 ├── fast-queries/          # Quick diagnostic scripts
 ├── speckit-workflow/      # Speckit phase management
 ├── specification/         # Feature specification workflow
-├── orchestrator-approval/ # T3 nonce approval relay for orchestrator
+├── orchestrator-approval/ # T3 approval presentation for orchestrator
 ├── approval/              # T3 plan presentation and approval workflow
 │   └── examples.md
 ├── execution/             # Post-approval execution protocol
@@ -65,9 +64,8 @@ skills:
 | speckit-planner | agent-protocol, security-tiers, speckit-workflow | - |
 
 Orchestrator skills (loaded on-demand via Skill tool, not assigned to agents):
-- **project-dispatch** -- agent table and dispatch rules
 - **agent-response** -- contract status interpretation and presentation
-- **orchestrator-approval** -- T3 nonce approval relay
+- **orchestrator-approval** -- T3 approval presentation and grant activation
 
 ## Skill Types
 
@@ -77,7 +75,7 @@ Orchestrator skills (loaded on-demand via Skill tool, not assigned to agents):
 | **Common** | Most agents via `skills:` | command-execution, context-updater |
 | **Domain** | Per-agent via `skills:` | terraform-patterns, gitops-patterns, developer-patterns, gaia-patterns |
 | **Workflow** | On-demand (agent reads file) | approval, execution, git-conventions |
-| **Orchestrator** | On-demand via Skill tool | project-dispatch, agent-response, orchestrator-approval |
+| **Orchestrator** | On-demand via Skill tool | agent-response, orchestrator-approval |
 
 Workflow skills are loaded on-demand -- agents read them from disk when needed rather than receiving them at startup. Supporting files (`examples.md`, `reference.md`) are also read on-demand.