--- /home/yeff/public_html/devon/docs/index.html.fix_schema.20260329_180114	2026-03-29 17:10:47.799557007 -0300
+++ /home/yeff/public_html/devon/docs/index.html	2026-04-10 22:02:24.032902725 -0300
@@ -1,3 +1,4 @@
+<?php require_once __DIR__ . "/../auth_guard.php"; ?>
 <!DOCTYPE html>
 <html lang="en">
 <head>
@@ -75,6 +76,25 @@
         min-width:0;
     }
 
+    .sidebar,
+    .rail{
+      scrollbar-width:thin;
+      scrollbar-color:rgba(138,167,255,.22) transparent;
+    }
+    .sidebar::-webkit-scrollbar,
+    .rail::-webkit-scrollbar{
+      width:10px;
+    }
+    .sidebar::-webkit-scrollbar-track,
+    .rail::-webkit-scrollbar-track{
+      background:transparent;
+    }
+    .sidebar::-webkit-scrollbar-thumb,
+    .rail::-webkit-scrollbar-thumb{
+      background:rgba(138,167,255,.22);
+      border-radius:999px;
+    }
+
     .brand{
       display:flex;
       flex-direction:column;
@@ -404,7 +424,7 @@
 
     .workspace{
       display:grid;
-      grid-template-columns:1.12fr .88fr;
+      grid-template-columns:1.2fr .8fr;
       gap:18px;
     }
 
@@ -656,7 +676,7 @@
         <div class="hero-actions">
           <a class="btn" href="../panel/" target="_blank" rel="noopener noreferrer">Open Panel</a>
           <a class="btn" href="../panel/data/panel_manifest.json" target="_blank" rel="noopener noreferrer">Manifest JSON</a>
-          <a class="btn" href="../panel/data/devon_panel_chat_checkpoint.md" target="_blank" rel="noopener noreferrer">Checkpoint MD</a>
+          <a class="btn" href="../panel/data/devon_continuity.md" target="_blank" rel="noopener noreferrer">Continuity MD</a>
         </div>
       </header>
 
@@ -707,13 +727,14 @@
             </div>
 
             <div class="doc-shell">
+              <div id="doc-map" class="doc-map"></div>
+
               <div class="viewer-actions">
                 <button id="btn-view-architecture" class="btn" type="button">View Architecture</button>
                 <button id="btn-view-contract" class="btn" type="button">View Contract</button>
                 <button id="btn-view-source" class="btn" type="button">View Canon Source</button>
               </div>
 
-              <div id="doc-map" class="doc-map"></div>
               <pre id="doc-viewer">Select a document in the Architecture Tree.</pre>
             </div>
           </article>
@@ -745,6 +766,8 @@
               <span class="chip">read-only canon</span>
               <span class="chip">no fake status</span>
               <span class="chip">docs as architecture</span>
+              <span class="chip">doc audit only</span>
+              <span class="chip">runtime in operator panel</span>
             </div>
           </article>
         </aside>
@@ -758,6 +781,11 @@
       </section>
 
       <section class="rail-card">
+        <h3>Audit split</h3>
+        <p>Documentation Hub audits canonical definition, category coverage, authority ownership, phase and layer binding, dependencies and documentation completion gaps. Operator Panel audits real implementation state, runtime evidence, health, telemetry, pipeline execution and server-side materialization.</p>
+      </section>
+
+      <section class="rail-card">
         <h3>Legend</h3>
         <div class="legend">
           <div class="legend-row"><div class="swatch"></div><span>control and structure layers</span></div>
@@ -769,13 +797,19 @@
       </section>
 
       <section class="rail-card">
+        <h3>Documentation structural coverage</h3>
+        <p id="doc-completeness-summary">Waiting for structural coverage analysis.</p>
+        <div id="doc-completeness-list" class="mini-list"></div>
+      </section>
+
+      <section class="rail-card">
         <h3>Canonical sources</h3>
         <div class="source-grid">
           <div class="source-item">../panel/data/master_architecture_index.md</div>
           <div class="source-item">../panel/data/panel_manifest.json</div>
           <div class="source-item">../panel/data/panel_content_index.json</div>
           <div class="source-item">../panel/data/project_scope_canonical.json</div>
-          <div class="source-item">../panel/data/devon_panel_chat_checkpoint.md</div>
+          <div class="source-item">../panel/data/devon_continuity.md</div>
 
           <div class="source-item">../panel/data/cas.md</div>
           <div class="source-item">../panel/data/cgs.md</div>
@@ -830,690 +864,34 @@
   </div>
 
   <script>
-    const HUB = {
-  "phases": [
-    {
-      "id": "phase-01",
-      "step": "Phase 01",
-      "name": "Overview & Scope",
-      "summary": "master root, project scope, manifest and continuity checkpoint.",
-      "badge": "overview_scope",
-      "layers": [
-        {
-          "title": "Overview & Scope",
-          "desc": "master registration, project framing, entry manifest and continuity checkpoint.",
-          "chips": [
-            "master root",
-            "project scope",
-            "entry manifest",
-            "checkpoint"
-          ]
-        }
-      ]
-    },
-    {
-      "id": "phase-02",
-      "step": "Phase 02",
-      "name": "Architecture & Engineering Canon",
-      "summary": "cognitive architecture, governance, artifact structure, contracts, naming, state legitimacy, build promotion, deployment structure and contextual satellites.",
-      "badge": "architecture_engineering_canon",
-      "layers": [
-        {
-          "title": "Architecture & Engineering Canon",
-          "desc": "authority and satellite documents that define Devon structural canon.",
-          "chips": [
-            "architecture",
-            "governance",
-            "contracts",
-            "naming",
-            "state legitimacy",
-            "deployment"
-          ]
-        }
-      ]
-    },
-    {
-      "id": "phase-03",
-      "step": "Phase 03",
-      "name": "Cognitive Flow Canon",
-      "summary": "deterministic orchestration, LLM role, retrieval role, validation order and execution gating.",
-      "badge": "cognitive_flow_canon",
-      "layers": [
-        {
-          "title": "Cognitive Flow Canon",
-          "desc": "interpreter, decision, validation, execution, memory and retrieval in governed flow.",
-          "chips": [
-            "interpreter",
-            "FSM",
-            "validation",
-            "execution",
-            "memory",
-            "retrieval"
-          ]
-        }
-      ]
-    },
-    {
-      "id": "phase-04",
-      "step": "Phase 04",
-      "name": "Containerization Canon",
-      "summary": "container topology, isolation and host versus container runtime boundaries.",
-      "badge": "containerization_canon",
-      "layers": [
-        {
-          "title": "Containerization Canon",
-          "desc": "runtime boundaries and isolation, without redefining sovereign architecture.",
-          "chips": [
-            "topology",
-            "isolation",
-            "runtime boundaries"
-          ]
-        }
-      ]
-    },
-    {
-      "id": "phase-05",
-      "step": "Phase 05",
-      "name": "Latency & Performance Canon",
-      "summary": "latency model, hot path versus cold path, bounded execution and fallback behavior.",
-      "badge": "latency_performance_canon",
-      "layers": [
-        {
-          "title": "Latency & Performance Canon",
-          "desc": "time traceability across modules, stages and end-to-end lifecycle.",
-          "chips": [
-            "latency",
-            "hot path",
-            "cold path",
-            "fallback"
-          ]
-        }
-      ]
-    },
-    {
-      "id": "phase-06",
-      "step": "Phase 06",
-      "name": "Noise Reduction Canon",
-      "summary": "signal preservation, redundancy elimination and unnecessary hop reduction.",
-      "badge": "noise_reduction_canon",
-      "layers": [
-        {
-          "title": "Noise Reduction Canon",
-          "desc": "remove architectural waste and keep deterministic path lean.",
-          "chips": [
-            "signal",
-            "redundancy elimination",
-            "less path"
-          ]
-        }
-      ]
-    },
-    {
-      "id": "phase-07",
-      "step": "Phase 07",
-      "name": "Observability & Audit Canon",
-      "summary": "audit-linked visibility, evidence continuity and operational observability.",
-      "badge": "observability_audit_canon",
-      "layers": [
-        {
-          "title": "Observability & Audit Canon",
-          "desc": "traceability for runtime, memory and protected execution.",
-          "chips": [
-            "observability",
-            "audit",
-            "evidence continuity"
-          ]
-        }
-      ]
-    },
-    {
-      "id": "phase-08",
-      "step": "Phase 08",
-      "name": "Security Canon",
-      "summary": "security governance, trust model, access boundaries, memory protection and monitoring.",
-      "badge": "security_canon",
-      "layers": [
-        {
-          "title": "Security Canon",
-          "desc": "security governance with structured implementation artifacts.",
-          "chips": [
-            "zero trust",
-            "access control",
-            "memory protection",
-            "monitoring"
-          ]
-        }
-      ]
-    },
-    {
-      "id": "phase-09",
-      "step": "Phase 09",
-      "name": "Operational Flows Canon",
-      "summary": "execution sequence, operating flow mapping and operational order integrity.",
-      "badge": "operational_flows_canon",
-      "layers": [
-        {
-          "title": "Operational Flows Canon",
-          "desc": "runtime sequence and flow order without redefining sovereign authorities.",
-          "chips": [
-            "operational flow",
-            "sequence",
-            "order integrity"
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    {
-      "id": "overview_scope",
-      "title": "Overview & Scope",
-      "sub": "master registration, project scope, manifest and continuity checkpoint.",
-      "badge": "phase 01",
-      "docs": [
-        {
-          "id": "master_architecture_index",
-          "title": "Master Architecture Index",
-          "path": "../panel/data/master_architecture_index.md",
-          "phase": "phase-01",
-          "layer": "overview_scope",
-          "role": "Supreme canonical root and registration authority.",
-          "fits": "Defines registration, precedence, authority ownership and completeness rules.",
-          "depends_on": "panel_manifest, project_scope, all phases, all categories",
-          "used_by": "all documentation hub structure",
-          "architecture_view": "Supreme human-readable root for all Devon canon."
-        },
-        {
-          "id": "panel_manifest",
-          "title": "Panel Manifest",
-          "path": "../panel/data/panel_manifest.json",
-          "phase": "phase-01",
-          "layer": "overview_scope",
-          "role": "Entry manifest and machine-readable panel entry point.",
-          "fits": "Belongs to project overview and registration surface.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Entry manifest for the panel and documentation surface."
-        },
-        {
-          "id": "project_scope",
-          "title": "Project Scope Canonical",
-          "path": "../panel/data/project_scope_canonical.json",
-          "phase": "phase-01",
-          "layer": "overview_scope",
-          "role": "Machine-readable project scope authority.",
-          "fits": "Defines project framing and scope surface.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Scope anchor for the project overview."
-        },
-        {
-          "id": "checkpoint_md",
-          "title": "Devon Panel Chat Checkpoint",
-          "path": "../panel/data/devon_panel_chat_checkpoint.md",
-          "phase": "phase-01",
-          "layer": "overview_scope",
-          "role": "Continuity checkpoint document.",
-          "fits": "Supports operational continuity and chat handoff.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Continuity artifact for human follow-up."
-        }
-      ]
-    },
-    {
-      "id": "architecture_engineering_core",
-      "title": "Architecture & Engineering Canon",
-      "sub": "authority and satellite documents for architecture, governance, contracts, naming, deployment and contextual boundaries.",
-      "badge": "phase 02",
-      "docs": [
-        {
-          "id": "cas",
-          "title": "CAS · Cognitive Architecture Spec",
-          "path": "../panel/data/cas.md",
-          "phase": "phase-02",
-          "layer": "architecture_engineering_core",
-          "role": "Primary authority for cognitive architecture placement.",
-          "fits": "Owns architecture layers and separation between probabilistic and deterministic components.",
-          "depends_on": "master_architecture_index",
-          "used_by": "cfc, ccc, lpc, sec, ofc",
-          "architecture_view": "Sovereign architecture meaning."
-        },
-        {
-          "id": "cgs",
-          "title": "CGS · Canonical Governance Spec",
-          "path": "../panel/data/cgs.md",
-          "phase": "phase-02",
-          "layer": "architecture_engineering_core",
-          "role": "Primary governance authority.",
-          "fits": "Owns governance structure and canonical responsibility boundaries.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Governance backbone of the structural canon."
-        },
-        {
-          "id": "acs",
-          "title": "ACS · Artifact Canon Structure",
-          "path": "../panel/data/acs.md",
-          "phase": "phase-02",
-          "layer": "architecture_engineering_core",
-          "role": "Primary artifact canon authority.",
-          "fits": "Defines artifact structure and canonical placement logic.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Artifact structure ownership."
-        },
-        {
-          "id": "css",
-          "title": "CSS · Contracts & Schemas Spec",
-          "path": "../panel/data/css.md",
-          "phase": "phase-02",
-          "layer": "architecture_engineering_core",
-          "role": "Primary contracts and schemas authority.",
-          "fits": "Owns contracts, schema legitimacy and structured interfaces.",
-          "depends_on": "master_architecture_index, panel_data_contract",
-          "used_by": "documentation hub, panel",
-          "architecture_view": "Schema and contract sovereignty."
-        },
-        {
-          "id": "ncs",
-          "title": "NCS · Naming Canon Spec",
-          "path": "../panel/data/ncs.md",
-          "phase": "phase-02",
-          "layer": "architecture_engineering_core",
-          "role": "Primary naming authority.",
-          "fits": "Owns naming legitimacy across canon artifacts.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Naming governance surface."
-        },
-        {
-          "id": "sts",
-          "title": "STS · State Transition Spec",
-          "path": "../panel/data/sts.md",
-          "phase": "phase-02",
-          "layer": "architecture_engineering_core",
-          "role": "Primary state legitimacy authority.",
-          "fits": "Owns state legitimacy and transition boundary rules.",
-          "depends_on": "master_architecture_index",
-          "used_by": "cfc, ofc",
-          "architecture_view": "State governance authority."
-        },
-        {
-          "id": "brps",
-          "title": "BRPS · Build Release Promotion Spec",
-          "path": "../panel/data/brps.md",
-          "phase": "phase-02",
-          "layer": "architecture_engineering_core",
-          "role": "Primary release and promotion authority.",
-          "fits": "Owns build, release and promotion rules.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Promotion governance surface."
-        },
-        {
-          "id": "cdms",
-          "title": "CDMS · Canonical Deployment Model Spec",
-          "path": "../panel/data/cdms.md",
-          "phase": "phase-02",
-          "layer": "architecture_engineering_core",
-          "role": "Primary deployment structure authority.",
-          "fits": "Owns deployment structure and placement boundaries.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Deployment structure authority."
-        },
-        {
-          "id": "ris",
-          "title": "RIS · Role Interaction Spec",
-          "path": "../panel/data/ris.md",
-          "phase": "phase-02",
-          "layer": "architecture_engineering_core",
-          "role": "Satellite contextual document.",
-          "fits": "Provides role interaction context without redefining sovereign authority.",
-          "depends_on": "cas, cfc",
-          "used_by": "documentation hub",
-          "architecture_view": "Contextual relation layer."
-        },
-        {
-          "id": "ofms",
-          "title": "OFMS · Operational Flow Mapping Spec",
-          "path": "../panel/data/ofms.md",
-          "phase": "phase-02",
-          "layer": "architecture_engineering_core",
-          "role": "Satellite contextual document.",
-          "fits": "Provides contextual flow mapping without redefining canonical flow.",
-          "depends_on": "cfc, ofc",
-          "used_by": "documentation hub",
-          "architecture_view": "Contextual flow map."
-        }
-      ]
-    },
-    {
-      "id": "cognitive_flow",
-      "title": "Cognitive Flow Canon",
-      "sub": "deterministic orchestration, validation order, execution gating and flow control.",
-      "badge": "phase 03",
-      "docs": [
-        {
-          "id": "cfc",
-          "title": "CFC · Cognitive Flow Canon",
-          "path": "../panel/data/cfc.md",
-          "phase": "phase-03",
-          "layer": "cognitive_flow",
-          "role": "Primary authority for deterministic orchestration.",
-          "fits": "Owns governed flow, validation order and execution permission.",
-          "depends_on": "cas, sts",
-          "used_by": "ofc, lpc, ris",
-          "architecture_view": "Sovereign flow meaning."
-        }
-      ]
-    },
-    {
-      "id": "containerization",
-      "title": "Containerization Canon",
-      "sub": "container topology, isolation and host versus container boundary.",
-      "badge": "phase 04",
-      "docs": [
-        {
-          "id": "ccc",
-          "title": "CCC · Containerization Canon",
-          "path": "../panel/data/ccc.md",
-          "phase": "phase-04",
-          "layer": "containerization",
-          "role": "Container topology and isolation reference.",
-          "fits": "Describes runtime boundaries without redefining system behavior.",
-          "depends_on": "cas, ris",
-          "used_by": "documentation hub",
-          "architecture_view": "Container boundary reference."
-        }
-      ]
-    },
-    {
-      "id": "latency_performance",
-      "title": "Latency & Performance Canon",
-      "sub": "latency model, hot path, cold path and bounded performance design.",
-      "badge": "phase 05",
-      "docs": [
-        {
-          "id": "lpc",
-          "title": "LPC · Latency & Performance Canon",
-          "path": "../panel/data/lpc.md",
-          "phase": "phase-05",
-          "layer": "latency_performance",
-          "role": "Primary latency budget authority.",
-          "fits": "Owns latency model, fallback rules and performance law.",
-          "depends_on": "cfc",
-          "used_by": "documentation hub",
-          "architecture_view": "Performance governance authority."
-        }
-      ]
-    },
-    {
-      "id": "noise_reduction",
-      "title": "Noise Reduction Canon",
-      "sub": "signal preservation, redundancy elimination and hop reduction.",
-      "badge": "phase 06",
-      "docs": [
-        {
-          "id": "nrc",
-          "title": "NRC · Noise Reduction Canon",
-          "path": "../panel/data/nrc.md",
-          "phase": "phase-06",
-          "layer": "noise_reduction",
-          "role": "Primary noise reduction authority.",
-          "fits": "Owns anti-redundancy and anti-waste architectural guidance.",
-          "depends_on": "lpc, cfc",
-          "used_by": "documentation hub",
-          "architecture_view": "Path simplification authority."
-        }
-      ]
-    },
-    {
-      "id": "observability_audit",
-      "title": "Observability & Audit Canon",
-      "sub": "audit-linked visibility, evidence traceability and observability control.",
-      "badge": "phase 07",
-      "docs": [
-        {
-          "id": "oac",
-          "title": "OAC · Observability & Audit Canon",
-          "path": "../panel/data/oac.md",
-          "phase": "phase-07",
-          "layer": "observability_audit",
-          "role": "Primary observability and audit authority.",
-          "fits": "Owns evidence traceability and audit-linked visibility.",
-          "depends_on": "cfc, sec",
-          "used_by": "documentation hub",
-          "architecture_view": "Auditability sovereignty."
-        }
-      ]
-    },
-    {
-      "id": "security_governance",
-      "title": "Security Canon",
-      "sub": "security governance authority plus structured implementation artifacts.",
-      "badge": "phase 08",
-      "docs": [
-        {
-          "id": "sec",
-          "title": "SEC · Security Canon",
-          "path": "../panel/data/sec.md",
-          "phase": "phase-08",
-          "layer": "security_governance",
-          "role": "Primary security governance authority.",
-          "fits": "Owns trust model, access control, memory protection and security monitoring expectations.",
-          "depends_on": "master_architecture_index",
-          "used_by": "host_security, app_security, module_security, runtime_security, delivery_security, approval_policy, memory_isolation, security_monitoring",
-          "architecture_view": "Sovereign security meaning."
-        },
-        {
-          "id": "host_security",
-          "title": "Host Security Canonical",
-          "path": "../panel/data/host_security_canonical.json",
-          "phase": "phase-08",
-          "layer": "security_governance",
-          "role": "Structured host security implementation.",
-          "fits": "Machine-readable host security canon.",
-          "depends_on": "sec",
-          "used_by": "documentation hub",
-          "architecture_view": "Host security implementation layer."
-        },
-        {
-          "id": "app_security",
-          "title": "App Security Canonical",
-          "path": "../panel/data/app_security_canonical.json",
-          "phase": "phase-08",
-          "layer": "security_governance",
-          "role": "Structured app security implementation.",
-          "fits": "Machine-readable application security canon.",
-          "depends_on": "sec",
-          "used_by": "documentation hub",
-          "architecture_view": "Application security implementation layer."
-        },
-        {
-          "id": "module_security",
-          "title": "Module Security Canonical",
-          "path": "../panel/data/module_security_canonical.json",
-          "phase": "phase-08",
-          "layer": "security_governance",
-          "role": "Structured module security implementation.",
-          "fits": "Machine-readable module security canon.",
-          "depends_on": "sec",
-          "used_by": "documentation hub",
-          "architecture_view": "Module security implementation layer."
-        },
-        {
-          "id": "runtime_security",
-          "title": "Runtime Security Canonical",
-          "path": "../panel/data/runtime_security_canonical.json",
-          "phase": "phase-08",
-          "layer": "security_governance",
-          "role": "Structured runtime security implementation.",
-          "fits": "Machine-readable runtime security canon.",
-          "depends_on": "sec",
-          "used_by": "documentation hub",
-          "architecture_view": "Runtime security implementation layer."
-        },
-        {
-          "id": "delivery_security",
-          "title": "Delivery Security Canonical",
-          "path": "../panel/data/delivery_security_canonical.json",
-          "phase": "phase-08",
-          "layer": "security_governance",
-          "role": "Structured delivery security implementation.",
-          "fits": "Machine-readable delivery security canon.",
-          "depends_on": "sec",
-          "used_by": "documentation hub",
-          "architecture_view": "Delivery security implementation layer."
-        },
-        {
-          "id": "approval_policy",
-          "title": "Approval Canonization Policy",
-          "path": "../panel/data/approval_canonization_policy.json",
-          "phase": "phase-08",
-          "layer": "security_governance",
-          "role": "Structured approval and canonization policy.",
-          "fits": "Machine-readable approval guardrails.",
-          "depends_on": "sec",
-          "used_by": "documentation hub",
-          "architecture_view": "Approval policy implementation layer."
-        },
-        {
-          "id": "memory_isolation",
-          "title": "Memory Isolation Canonical",
-          "path": "../panel/data/memory_isolation_canonical.json",
-          "phase": "phase-08",
-          "layer": "security_governance",
-          "role": "Structured memory isolation canon.",
-          "fits": "Machine-readable memory partition and isolation rules.",
-          "depends_on": "sec",
-          "used_by": "documentation hub",
-          "architecture_view": "Memory isolation implementation layer."
-        },
-        {
-          "id": "security_monitoring",
-          "title": "Security Monitoring Canonical",
-          "path": "../panel/data/security_monitoring_canonical.json",
-          "phase": "phase-08",
-          "layer": "security_governance",
-          "role": "Structured security monitoring canon.",
-          "fits": "Machine-readable security monitoring rules.",
-          "depends_on": "sec",
-          "used_by": "documentation hub",
-          "architecture_view": "Security monitoring implementation layer."
-        }
-      ]
-    },
-    {
-      "id": "operational_flows",
-      "title": "Operational Flows Canon",
-      "sub": "operational sequence, runtime flow order and end-to-end action routing.",
-      "badge": "phase 09",
-      "docs": [
-        {
-          "id": "ofc",
-          "title": "OFC · Operational Flows Canon",
-          "path": "../panel/data/ofc.md",
-          "phase": "phase-09",
-          "layer": "operational_flows",
-          "role": "Primary operational flow authority.",
-          "fits": "Owns operational sequence and ordered runtime flow expectations.",
-          "depends_on": "cfc, sts",
-          "used_by": "documentation hub",
-          "architecture_view": "Operational flow sovereignty."
-        }
-      ]
-    },
-    {
-      "id": "memory_learning_reasoning",
-      "title": "Memory, Learning & Reasoning Governance",
-      "sub": "expanded canonical domains registered in the master v2.0.",
-      "badge": "master v2.0",
-      "docs": [
-        {
-          "id": "memory_arch",
-          "title": "Memory Canonical Architecture",
-          "path": "../panel/data/memory_canonical_architecture.json",
-          "phase": "phase-02",
-          "layer": "memory_learning_reasoning",
-          "role": "Structured memory architecture canon.",
-          "fits": "Machine-readable memory architecture baseline.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Memory architecture support layer."
-        },
-        {
-          "id": "memory_lifecycle",
-          "title": "Memory Lifecycle Canonical",
-          "path": "../panel/data/memory_lifecycle_canonical.json",
-          "phase": "phase-02",
-          "layer": "memory_learning_reasoning",
-          "role": "Structured memory lifecycle canon.",
-          "fits": "Machine-readable consolidation and lifecycle rules.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Memory lifecycle support layer."
-        },
-        {
-          "id": "learning_gov",
-          "title": "Learning Governance Canonical",
-          "path": "../panel/data/learning_governance_canonical.json",
-          "phase": "phase-02",
-          "layer": "memory_learning_reasoning",
-          "role": "Structured learning governance canon.",
-          "fits": "Machine-readable learning guardrails.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Learning governance support layer."
-        },
-        {
-          "id": "planning_reasoning",
-          "title": "Planning Reasoning Canonical",
-          "path": "../panel/data/planning_reasoning_canonical.json",
-          "phase": "phase-02",
-          "layer": "memory_learning_reasoning",
-          "role": "Structured planning and reasoning canon.",
-          "fits": "Machine-readable planning and reasoning boundaries.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Planning governance support layer."
-        },
-        {
-          "id": "tool_execution",
-          "title": "Tool Execution Canonical",
-          "path": "../panel/data/tool_execution_canonical.json",
-          "phase": "phase-02",
-          "layer": "memory_learning_reasoning",
-          "role": "Structured tool execution canon.",
-          "fits": "Machine-readable permission and execution boundaries.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Tool execution governance support layer."
-        },
-        {
-          "id": "knowledge_ingestion",
-          "title": "Knowledge Ingestion Canonical",
-          "path": "../panel/data/knowledge_ingestion_canonical.json",
-          "phase": "phase-02",
-          "layer": "memory_learning_reasoning",
-          "role": "Structured knowledge ingestion canon.",
-          "fits": "Machine-readable ingestion and indexing boundaries.",
-          "depends_on": "master_architecture_index",
-          "used_by": "documentation hub",
-          "architecture_view": "Knowledge ingestion support layer."
-        }
-      ]
-    }
-  ]
-};
+        
+let HUB = null;
+
+async function loadHub() {
+  if (HUB) return HUB;
+
+  const [hubRes, treeRes] = await Promise.all([
+    fetch('../panel/data/hub_index.json', { cache: 'no-store' }),
+    fetch('../panel/data/panel_canonical_tree.json', { cache: 'no-store' })
+  ]);
+
+  if (!hubRes.ok) throw new Error('hub load fail');
+  if (!treeRes.ok) throw new Error('canonical tree load fail');
+
+  const [hubIndex, canonicalTree] = await Promise.all([
+    hubRes.json(),
+    treeRes.json()
+  ]);
+
+  HUB = {
+    index: hubIndex,
+    tree: canonicalTree
+  };
+
+  return HUB;
+}
 
-    const state = {
-      phaseId: HUB.phases[0].id,
-      categoryId: HUB.categories[0].id,
-      docId: HUB.categories[0].docs[0].id,
-      mode: "architecture"
-    };
+let state = { phaseId: null, categoryId: null, docId: null, selectedSubcategory: null, mode: "architecture" };
 
     const treeRoot = document.getElementById("tree-root");
     const phaseStrip = document.getElementById("phase-strip");
@@ -1531,37 +909,138 @@
     const docMap = document.getElementById("doc-map");
     const docViewer = document.getElementById("doc-viewer");
     const relationMap = document.getElementById("relation-map");
+    const docCompletenessSummary = document.getElementById("doc-completeness-summary");
+    const docCompletenessList = document.getElementById("doc-completeness-list");
 
     const btnViewArchitecture = document.getElementById("btn-view-architecture");
     const btnViewContract = document.getElementById("btn-view-contract");
     const btnViewSource = document.getElementById("btn-view-source");
+      function hubIndex(){
+        return HUB && HUB.index ? HUB.index : { phases: [], categories: [] };
+      }
 
-    function getCategory(categoryId){
-      return HUB.categories.find(c => c.id === categoryId);
-    }
+      function hubTree(){
+        return HUB && HUB.tree ? HUB.tree : { phases: [] };
+      }
 
-    function getDoc(categoryId, docId){
-      const category = getCategory(categoryId);
-      return category ? category.docs.find(d => d.id === docId) : null;
-    }
+      function getCategory(categoryId){
+        return (hubIndex().categories || []).find(c => c.id === categoryId) || null;
+      }
+
+      function getDoc(categoryId, docId){
+        const category = getCategory(categoryId);
+        return category ? ((category.docs || []).find(d => d.id === docId) || null) : null;
+      }
+
+      function getPhase(phaseId){
+        return (hubIndex().phases || []).find(p => p.id === phaseId) || null;
+      }
+
+      function getTreePhase(phaseId){
+        return (hubTree().phases || []).find(p => p.id === phaseId) || null;
+      }
+
+      function getTreeCategory(phaseId, categoryId){
+        const phase = getTreePhase(phaseId);
+        return phase ? ((phase.categories || []).find(c => c.id === categoryId) || null) : null;
+      }
+
+      function getSubcategories(phaseId, categoryId){
+        const category = getTreeCategory(phaseId, categoryId);
+        return category && Array.isArray(category.subcategories) ? category.subcategories : [];
+      }
+
+      function getSelectedSubcategory(){
+        const subcategories = getSubcategories(state.phaseId, state.categoryId);
+        if (!subcategories.length) return null;
+        if (state.selectedSubcategory) {
+          const hit = subcategories.find(s => s.id === state.selectedSubcategory);
+          if (hit) return hit;
+        }
+        return subcategories[0];
+      }
 
-    function getPhase(phaseId){
-      return HUB.phases.find(p => p.id === phaseId);
-    }
 
     function metricData(){
-      const totalCategories = HUB.categories.length;
-      const totalDocs = HUB.categories.reduce((acc, cat) => acc + cat.docs.length, 0);
-      const totalPhases = HUB.phases.length;
+      const totalCategories = hubIndex().categories.length;
+      const totalDocs = hubIndex().categories.reduce((acc, cat) => acc + ((cat.docs || []).length), 0);
+      const totalPhases = hubIndex().phases.length;
       const totalSources = totalDocs;
+      const categoriesWithGaps = hubIndex().categories.filter(cat => !Array.isArray(cat.docs) || !cat.docs.length).length;
       return [
         { value: totalPhases, label: "Phases", note: "macro build stages" },
         { value: totalCategories, label: "Categories", note: "navigation domains" },
         { value: totalDocs, label: "Documents", note: "canonical source set" },
-        { value: totalSources, label: "Mapped Sources", note: "doc-to-source bindings" }
+        { value: totalSources, label: "Mapped Sources", note: "doc-to-source bindings" },
+        { value: totalCategories - categoriesWithGaps, label: "Ready Categories", note: "categories with mapped docs" }
       ];
     }
 
+    function documentationCompletenessSnapshot(){
+      const categories = Array.isArray(hubIndex().categories) ? hubIndex().categories : [];
+      const phases = Array.isArray(hubIndex().phases) ? hubIndex().phases : [];
+      const docs = categories.reduce((acc, cat) => acc + (Array.isArray(cat.docs) ? cat.docs.length : 0), 0);
+
+      const categoriesWithDocs = categories.filter(cat => Array.isArray(cat.docs) && cat.docs.length > 0);
+      const missingCategoryDocs = categories.filter(cat => !Array.isArray(cat.docs) || cat.docs.length === 0);
+
+      const docsMissingPhase = [];
+      const docsMissingDepends = [];
+      const docsMissingUsedBy = [];
+
+      categories.forEach(cat => {
+        (Array.isArray(cat.docs) ? cat.docs : []).forEach(doc => {
+          if (!doc.phase) docsMissingPhase.push(doc.label || doc.id || "unnamed-doc");
+          if (!Array.isArray(doc.depends_on) || doc.depends_on.length === 0) docsMissingDepends.push(doc.label || doc.id || "unnamed-doc");
+          if (!Array.isArray(doc.used_by) || doc.used_by.length === 0) docsMissingUsedBy.push(doc.label || doc.id || "unnamed-doc");
+        });
+      });
+
+      return {
+        totalPhases: phases.length,
+        totalCategories: categories.length,
+        totalDocs: docs,
+        categoriesWithDocs: categoriesWithDocs.length,
+        missingCategoryDocs,
+        docsMissingPhase,
+        docsMissingDepends,
+        docsMissingUsedBy
+      };
+    }
+
+    function buildDocumentationCompleteness(){
+      if (!docCompletenessSummary || !docCompletenessList) return;
+
+      const snap = documentationCompletenessSnapshot();
+      const categoriesWithoutDocs = snap.missingCategoryDocs.length;
+      const docsMissingPhase = snap.docsMissingPhase.length;
+      const docsMissingDepends = snap.docsMissingDepends.length;
+      const docsMissingUsedBy = snap.docsMissingUsedBy.length;
+
+      const categoriesReady = snap.totalCategories - categoriesWithoutDocs;
+      const totalGapCount = categoriesWithoutDocs + docsMissingPhase + docsMissingDepends + docsMissingUsedBy;
+
+      docCompletenessSummary.textContent =
+        totalGapCount === 0
+          ? "Structural coverage is complete for the current Hub surface."
+          : "Structural coverage is active, but mapped gaps still exist and are listed below.";
+
+      docCompletenessList.innerHTML = "";
+
+      [
+        { title: "Covered categories", text: `${categoriesReady} / ${snap.totalCategories} categories with mapped docs.` },
+        { title: "Category gaps", text: categoriesWithoutDocs ? `${categoriesWithoutDocs} categories still have no mapped docs.` : "No category-level doc gaps detected." },
+        { title: "Phase binding gaps", text: docsMissingPhase ? `${docsMissingPhase} docs still have no explicit phase binding.` : "No phase-binding gaps detected." },
+        { title: "Dependency gaps", text: docsMissingDepends ? `${docsMissingDepends} docs still have no depends_on mapping.` : "No depends_on gaps detected." },
+        { title: "Usage gaps", text: docsMissingUsedBy ? `${docsMissingUsedBy} docs still have no used_by mapping.` : "No used_by gaps detected." }
+      ].forEach(item => {
+        const el = document.createElement("div");
+        el.className = "mini-item";
+        el.innerHTML = `<strong>${item.title}</strong><span>${item.text}</span>`;
+        docCompletenessList.appendChild(el);
+      });
+    }
+
     function buildMetrics(){
       metricGrid.innerHTML = "";
       metricData().forEach(item => {
@@ -1575,10 +1054,9 @@
         metricGrid.appendChild(el);
       });
     }
-
     function buildPhases(){
       phaseStrip.innerHTML = "";
-      HUB.phases.forEach(phase => {
+      (hubIndex().phases || []).forEach(phase => {
         const btn = document.createElement("button");
         btn.type = "button";
         btn.className = "phase" + (phase.id === state.phaseId ? " active" : "");
@@ -1590,68 +1068,86 @@
         btn.title = phase.summary;
         btn.addEventListener("click", () => {
           state.phaseId = phase.id;
-          const matchingCategory = HUB.categories.find(cat => cat.docs.some(doc => doc.phase === phase.id));
-          if (matchingCategory) {
-            state.categoryId = matchingCategory.id;
-            state.docId = matchingCategory.docs[0].id;
+
+          const phaseTree = getTreePhase(phase.id);
+          const firstCategory = phaseTree && Array.isArray(phaseTree.categories)
+            ? phaseTree.categories[0]
+            : null;
+
+          if (firstCategory) {
+            state.categoryId = firstCategory.id;
+            state.selectedSubcategory = null;
           }
+
+          state.docId = null;
           render();
         });
         phaseStrip.appendChild(btn);
       });
     }
-
     function buildTree(){
       treeRoot.innerHTML = "";
-      HUB.categories.forEach(cat => {
-        const node = document.createElement("div");
-        const isOpen = cat.id === state.categoryId;
-        node.className = "tree-node" + (isOpen ? " open" : "");
-
-        const head = document.createElement("div");
-        head.className = "tree-head";
-        head.innerHTML = `
+
+      (hubIndex().phases || []).forEach(phase => {
+        const phaseNode = document.createElement("div");
+        const phaseOpen = phase.id === state.phaseId;
+        phaseNode.className = "tree-node" + (phaseOpen ? " open" : "");
+
+        const phaseHead = document.createElement("div");
+        phaseHead.className = "tree-head";
+        phaseHead.innerHTML = `
           <div class="tree-head-left">
-            <div class="tree-title">${cat.title}</div>
-            <div class="tree-sub">${cat.sub}</div>
+            <div class="tree-title">${phase.name}</div>
+            <div class="tree-sub">${phase.summary || ""}</div>
           </div>
-          <span class="tree-badge">${cat.badge}</span>
+          <span class="tree-badge">${phase.badge || phase.step || ""}</span>
         `;
-        head.addEventListener("click", () => {
-          state.categoryId = cat.id;
-          const firstDoc = cat.docs[0];
-          if (firstDoc) {
-            state.docId = firstDoc.id;
-            state.phaseId = firstDoc.phase;
+        phaseHead.addEventListener("click", () => {
+          state.phaseId = phase.id;
+
+          const phaseTree = getTreePhase(phase.id);
+          const firstCategory = phaseTree && Array.isArray(phaseTree.categories)
+            ? phaseTree.categories[0]
+            : null;
+
+          if (firstCategory) {
+            state.categoryId = firstCategory.id;
+            state.selectedSubcategory = null;
           }
+
+          state.docId = null;
           render();
         });
 
-        const children = document.createElement("div");
-        children.className = "tree-children";
+        const phaseChildren = document.createElement("div");
+        phaseChildren.className = "tree-children";
 
-        cat.docs.forEach(doc => {
+        const phaseTree = getTreePhase(phase.id);
+        (phaseTree && Array.isArray(phaseTree.categories) ? phaseTree.categories : []).forEach(catTree => {
+          const catMeta = getCategory(catTree.id) || {};
           const btn = document.createElement("button");
           btn.type = "button";
-          btn.className = "tree-doc" + (doc.id === state.docId ? " active" : "");
-          btn.innerHTML = `${doc.label}<small>${doc.layer} • ${doc.type}</small>`;
+          btn.className = "tree-doc" + (catTree.id === state.categoryId ? " active" : "");
+          btn.innerHTML = `${catMeta.title || catTree.id}<small>${catMeta.sub || "category"}</small>`;
           btn.addEventListener("click", (ev) => {
             ev.stopPropagation();
-            state.categoryId = cat.id;
-            state.docId = doc.id;
-            state.phaseId = doc.phase;
+            state.phaseId = phase.id;
+            state.categoryId = catTree.id;
+            state.selectedSubcategory = null;
+            state.docId = null;
             render();
           });
-          children.appendChild(btn);
+          phaseChildren.appendChild(btn);
         });
 
-        node.appendChild(head);
-        node.appendChild(children);
-        treeRoot.appendChild(node);
+        phaseNode.appendChild(phaseHead);
+        phaseNode.appendChild(phaseChildren);
+        treeRoot.appendChild(phaseNode);
       });
     }
 
     function buildPhaseMap(){
+
       const phase = getPhase(state.phaseId);
       if (!phase) return;
 
@@ -1894,16 +1390,37 @@
       };
     }
 
-    function render(){
+    
+function init(){
+  state.phaseId = HUB.phases[0].id;
+  state.categoryId = HUB.categories[0].id;
+  state.docId = HUB.categories[0].docs[0].id;
+
+  bindModes();
+  render();
+}
+
+function render(){
       buildTree();
       buildPhases();
       buildMetrics();
+      buildDocumentationCompleteness();
       buildPhaseMap();
       renderDocViewer();
     }
 
-    bindModes();
-    render();
-  </script>
+    
+  
+(async () => {
+  try {
+    await loadHub();
+    init();
+  } catch (e) {
+    console.error("BOOT_FAIL", e);
+    document.body.innerHTML = "<pre>Failed to load HUB</pre>";
+  }
+})();
+
+</script>
 </body>
 </html>
