feat(cya): T01-T07 core console-native MVP slice (CYA-WP-0001)

- T01: Python + Typer/rich + pyproject.toml + full src/ layout + working `cya` CLI entrypoint
- T02: Bounded transparent context collector (top-level only, provenance, ignores) + --explain-context
- T03: Genuine rule-based risk classifier (primary) + mandatory terminal confirmation, no auto-execute
- T04: LLMAdapter Protocol + deterministic FakeLLMAdapter seam (llm-connect boundary, zero bypass)
- T05: Strictly minimal phase-memory no-op ports (loud markers, per operator direction 2026-05-26)
- T06: Orchestrator coordinating the full flow; CLI is thin delegation
- T07: pytest harness + safety-focused tests (risk invariants + collector)

All changes verified by running the installed `cya` binary and `pytest tests/`.

Workplan updated with status. State Hub progress event logged (workstream 0a1233fd...).

Refs: CYA-WP-0001, Decision a644364b-11c4-49a9-bf17-99063382e27b

src/cya/orchestrator.py

@@ -0,0 +1,117 @@
+"""Assistance orchestrator (T06).
+
+The piece that turns raw user intent + collected context into a well-formed
+request for the LLM adapter (T04), then turns the adapter response into the
+final terminal output the user sees.
+
+Responsibilities in this slice:
+- Own the end-to-end happy path after Typer argument parsing.
+- Coordinate context collector (T02), risk classifier (T03), and LLMAdapter (T04).
+- Keep the CLI surface (main.py) thin — it should only do argument parsing,
+  help/version, and delegation to this orchestrator.
+- Be testable in isolation with the FakeLLMAdapter (critical for T07).
+
+This module is the natural home for future prompt framing, context packing
+with token awareness, safety charter injection, and response post-processing.
+
+See workplan CYA-WP-0001-T06.
+"""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.panel import Panel
+
+from cya.context.collector import collect, render_explanation
+from cya.safety.risk import classify, get_user_confirmation
+from cya.llm.adapter import AssistanceRequest, FakeLLMAdapter
+
+
+console = Console()
+
+
+def handle_request(
+    user_request: str,
+    *,
+    explain_context: bool = False,
+    dry_run: bool = False,
+) -> None:
+    """Primary orchestrator entry point.
+
+    This is what the CLI (and future tests / other front-ends) should call.
+    It coordinates the full current flow:
+        context → safety (with mandatory confirmation) → LLMAdapter → render
+    """
+    # 1. Context (always cheap; needed for safety "affected" and for the adapter)
+    try:
+        envelope = collect(".")
+    except Exception:
+        envelope = None
+
+    if explain_context and envelope:
+        try:
+            explanation = render_explanation(envelope)
+            console.print(
+                Panel(
+                    explanation,
+                    title="Context Envelope (T02)",
+                    border_style="green",
+                    padding=(1, 1),
+                )
+            )
+        except Exception as exc:
+            console.print(f"[red]Context explanation error: {exc}[/red]")
+
+    # 2. Risk classification + mandatory confirmation (T03)
+    assessment = classify(user_request, envelope)
+
+    if assessment.requires_confirmation:
+        from rich.table import Table
+
+        table = Table(
+            title=f"Risk Assessment — {assessment.level.value.upper()}",
+            show_header=False,
+            border_style="red",
+        )
+        table.add_row("Rationale", assessment.rationale)
+        if assessment.preview:
+            table.add_row("Preview", assessment.preview)
+        if assessment.affected_summary:
+            table.add_row("Would affect", assessment.affected_summary)
+        table.add_row("Rules", ", ".join(assessment.rules_triggered[:3]))
+        console.print(table)
+
+        if not get_user_confirmation(assessment):
+            console.print("[yellow]Action cancelled by user. No changes made.[/yellow]")
+            return
+
+    if dry_run:
+        console.print("[green]--dry-run acknowledged.[/green] No side-effects.")
+        return
+
+    # 3. Call through the single LLMAdapter boundary (T04)
+    adapter = FakeLLMAdapter()
+    llm_request = AssistanceRequest(
+        user_request=user_request,
+        context=envelope.to_dict() if envelope else None,
+    )
+    llm_response = adapter.complete(llm_request)
+
+    # 4. Render final user-facing artifact (T06 responsibility)
+    console.print(
+        Panel(
+            f"[bold]Suggestion:[/bold]\n{llm_response.suggestion}\n\n"
+            f"[dim]{llm_response.explanation}\n"
+            f"Rationale: {llm_response.rationale}[/dim]",
+            title="LLM Response (via T04 seam)",
+            border_style="magenta",
+            padding=(1, 1),
+        )
+    )
+
+    console.print(
+        "[green]✓[/green] Request processed by orchestrator (T02+T03+T04 coordinated by T06)."
+    )
+
+
+__all__ = ["handle_request"]