feat: Phase 5B-5D — 10 canonical engineering queries + triage UI

The graph becomes useful. Before this commit, entities sat in the DB
as data with no narrative. After: the director can ask "what am I
forgetting?" and get a structured answer in milliseconds.

New module (src/atocore/engineering/queries.py, 360 lines):

Structure queries (Q-001/004/005/008/013):
- system_map(project): full subsystem → component tree + orphans +
  materials joined per component
- decisions_affecting(project, subsystem_id?): decisions linked via
  AFFECTED_BY_DECISION, scoped to a subsystem or whole project
- requirements_for(component_id): Q-005 forward trace
- recent_changes(project, since, limit): Q-013 via memory_audit join
  (reuses the Phase 4 audit infrastructure — entity_kind='entity')

The 3 killer queries (the real value):
- orphan_requirements(project): requirements with NO inbound SATISFIES
  edge. "What do I claim the system must do that nothing actually
  claims to handle?" Q-006.
- risky_decisions(project): decisions whose BASED_ON_ASSUMPTION edge
  points to an assumption with status in ('superseded','invalid') OR
  properties.flagged=True. Finds cascading risk from shaky premises. Q-009.
- unsupported_claims(project): ValidationClaim entities with no inbound
  SUPPORTS edge — asserted but no Result to back them. Q-011.
- all_gaps(project): runs all three in one call for dashboards.

History + impact (Q-016/017):
- impact_analysis(entity_id, max_depth=3): BFS over outbound edges.
  "What's downstream of this if I change it?"
- evidence_chain(entity_id): inbound SUPPORTS/EVIDENCED_BY/DESCRIBED_BY/
  VALIDATED_BY/ANALYZED_BY. "How do I know this is true?"

API (src/atocore/api/routes.py) exposes 10 endpoints:
- GET /engineering/projects/{p}/systems
- GET /engineering/decisions?project=&subsystem=
- GET /engineering/components/{id}/requirements
- GET /engineering/changes?project=&since=&limit=
- GET /engineering/gaps/orphan-requirements?project=
- GET /engineering/gaps/risky-decisions?project=
- GET /engineering/gaps/unsupported-claims?project=
- GET /engineering/gaps?project=  (combined)
- GET /engineering/impact?entity=&max_depth=
- GET /engineering/evidence?entity=

Mirror integration (src/atocore/engineering/mirror.py):
- New _gaps_section() renders at top of every project page
- If any gap non-empty: shows up-to-10 per category with names + context
- Clean project: "✅ No gaps detected" — signals everything is traced

Triage UI (src/atocore/engineering/triage_ui.py):
- /admin/triage now shows BOTH memory candidates AND entity candidates
- Entity cards: name, type, project, confidence, source provenance,
  Promote/Reject buttons, link to wiki entity page
- Entity promote/reject via fetch to /entities/{id}/promote|reject
- One triage UI for the whole pipeline — consistent muscle memory

Tests: 326 → 341 (15 new, all in test_engineering_queries.py):
- System map structure + orphan detection + material joins
- Killer queries: positive + negative cases (empty when clean)
- Decisions query: project-wide and subsystem-scoped
- Impact analysis walks outbound BFS
- Evidence chain walks inbound provenance

No regressions. All 10 daily queries from the plan are now live and
answering real questions against the graph.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

src/atocore/engineering/mirror.py

@@ -29,6 +29,7 @@ def generate_project_overview(project: str) -> str:
     sections = [
         _header(project),
         _synthesis_section(project),
+        _gaps_section(project),  # Phase 5: killer queries surface here
         _state_section(project),
         _system_architecture(project),
         _decisions_section(project),
@@ -41,6 +42,66 @@ def generate_project_overview(project: str) -> str:
     return "\n\n".join(s for s in sections if s)
 
 
+def _gaps_section(project: str) -> str:
+    """Phase 5: surface the 3 killer-query gaps on every project page.
+
+    If any gap is non-empty, it appears near the top so the director
+    sees "what am I forgetting?" before the rest of the report.
+    """
+    try:
+        from atocore.engineering.queries import all_gaps
+        result = all_gaps(project)
+    except Exception:
+        return ""
+
+    orphan = result["orphan_requirements"]["count"]
+    risky = result["risky_decisions"]["count"]
+    unsup = result["unsupported_claims"]["count"]
+
+    if orphan == 0 and risky == 0 and unsup == 0:
+        return (
+            "## Coverage Gaps\n\n"
+            "> ✅ No gaps detected: every requirement is satisfied, "
+            "no decisions rest on flagged assumptions, every claim has evidence.\n"
+        )
+
+    lines = ["## Coverage Gaps", ""]
+    lines.append(
+        "> ⚠️ Items below need attention — gaps in the engineering graph.\n"
+    )
+
+    if orphan:
+        lines.append(f"### {orphan} Orphan Requirement(s)")
+        lines.append("*Requirements with no component claiming to satisfy them:*")
+        lines.append("")
+        for r in result["orphan_requirements"]["gaps"][:10]:
+            lines.append(f"- **{r['name']}** — {(r['description'] or '')[:120]}")
+        if orphan > 10:
+            lines.append(f"- _...and {orphan - 10} more_")
+        lines.append("")
+
+    if risky:
+        lines.append(f"### {risky} Risky Decision(s)")
+        lines.append("*Decisions based on assumptions that are flagged, superseded, or invalid:*")
+        lines.append("")
+        for d in result["risky_decisions"]["gaps"][:10]:
+            lines.append(
+                f"- **{d['decision_name']}** — based on flagged assumption "
+                f"_{d['assumption_name']}_ ({d['assumption_status']})"
+            )
+        lines.append("")
+
+    if unsup:
+        lines.append(f"### {unsup} Unsupported Claim(s)")
+        lines.append("*Validation claims with no supporting Result entity:*")
+        lines.append("")
+        for c in result["unsupported_claims"]["gaps"][:10]:
+            lines.append(f"- **{c['name']}** — {(c['description'] or '')[:120]}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
 def _synthesis_section(project: str) -> str:
     """Generate a short LLM synthesis of the current project state.