@mindrian_os/cli 1.13.0-beta.10 → 1.13.0-beta.44

package/references/brain/command-triggers-schema.md

@@ -1,226 +0,0 @@
-# Brain Command Trigger Schema
-
-## Purpose
-
-Commands are first-class nodes in the Neo4j Brain. They have typed relationships to Frameworks, ProblemTypes, VentureStages, and Signals that define WHEN they should fire. The Brain doesn't just recommend frameworks -- it recommends ACTIONS mapped to specific /mos: commands with trigger conditions.
-
-## Node: Command
-
-```cypher
-CREATE (c:Command {
-  name: '/mos:find-analogies',
-  slug: 'find-analogies',
-  category: 'intelligence',          // infrastructure | methodology | intelligence | export | meeting | funding
-  description: 'Cross-domain analogy discovery via structural isomorphism',
-  jtbd_when: 'stuck on a problem that feels unique to your domain',
-  jtbd_want: 'discover that other industries already solved the same structural conflict',
-  jtbd_so: 'adapt their approach instead of inventing from scratch',
-  time_estimate: '5 minutes',
-  flags: ['--brain', '--external'],   // available flags
-  min_sections: 2,                    // minimum populated sections to be relevant
-  requires_brain: false,              // works without Brain (but better with)
-  powerhouse: true                    // v1.6.0+ feature
-})
-```
-
-## Relationships
-
-### TRIGGERED_BY_SIGNAL
-
-Links a Command to the Room Signal types that should trigger it.
-
-```cypher
-// When a CONTRADICTS edge exists between sections -> suggest find-analogies
-CREATE (cmd:Command {name: '/mos:find-analogies'})-[:TRIGGERED_BY_SIGNAL {
-  signal_type: 'TENSION',            // TENSION | BLIND_SPOT | BOTTLENECK | PATTERN | SURPRISE
-  priority: 1,                        // 1=highest, 5=lowest
-  condition: 'contradicts_count >= 1',
-  jtbd_framing: 'When your Sections have unresolved Tensions, you want to see how other domains resolved the same structural conflict'
-}]->(sig:SignalType {name: 'TENSION'})
-
-// When 3+ sections have gaps -> suggest act --swarm
-CREATE (cmd:Command {name: '/mos:act --swarm'})-[:TRIGGERED_BY_SIGNAL {
-  signal_type: 'BLIND_SPOT',
-  priority: 1,
-  condition: 'gap_count >= 3',
-  jtbd_framing: 'When 3+ Sections have Blind Spots, you want to fill them all at once instead of one at a time'
-}]->(sig:SignalType {name: 'BLIND_SPOT'})
-
-// When reverse salients detected -> suggest specific methodology for lagging section
-CREATE (cmd:Command {name: '/mos:act'})-[:TRIGGERED_BY_SIGNAL {
-  signal_type: 'BOTTLENECK',
-  priority: 2,
-  condition: 'reverse_salient_count >= 1',
-  jtbd_framing: 'When a Section lags behind the others, you want to close the gap before it compounds'
-}]->(sig:SignalType {name: 'BOTTLENECK'})
-```
-
-### FOLLOWS_FRAMEWORK
-
-Links a Command to the Framework it should follow (chaining).
-
-```cypher
-// After JTBD analysis -> suggest Blue Ocean
-CREATE (cmd:Command {name: '/mos:dominant-designs'})-[:FOLLOWS_FRAMEWORK {
-  confidence: 0.85,
-  reason: 'JTBD reveals customer needs; dominant designs reveals competitive whitespace',
-  hop_distance: 1
-}]->(f:Framework {name: 'Jobs-to-Be-Done'})
-
-// After find-analogies -> suggest validate (stress-test the analogy)
-CREATE (cmd:Command {name: '/mos:validate'})-[:FOLLOWS_FRAMEWORK {
-  confidence: 0.90,
-  reason: 'Analogies must be stress-tested before acting on them',
-  hop_distance: 1
-}]->(f:Framework {name: 'Design-by-Analogy'})
-
-// After grade --full -> suggest act --swarm on weak sections
-CREATE (cmd:Command {name: '/mos:act --swarm'})-[:FOLLOWS_FRAMEWORK {
-  confidence: 0.80,
-  reason: 'Grading reveals gaps; swarm attacks them in parallel',
-  hop_distance: 1
-}]->(f:Framework {name: 'Assessment'})
-```
-
-### RELEVANT_AT_STAGE
-
-Links a Command to VentureStages where it's most impactful.
-
-```cypher
-// find-analogies is most powerful at Discovery and Design stages
-CREATE (cmd:Command {name: '/mos:find-analogies'})-[:RELEVANT_AT_STAGE {
-  impact: 'high',
-  reason: 'Discovery needs fresh perspectives; Design needs proven patterns'
-}]->(stage:VentureStage {name: 'Discovery'})
-
-// grade --full becomes critical at Investment stage
-CREATE (cmd:Command {name: '/mos:grade --full'})-[:RELEVANT_AT_STAGE {
-  impact: 'critical',
-  reason: 'Investment stage demands rigor across every Section'
-}]->(stage:VentureStage {name: 'Investment'})
-
-// scout is always relevant but especially at Validation
-CREATE (cmd:Command {name: '/mos:scout'})-[:RELEVANT_AT_STAGE {
-  impact: 'high',
-  reason: 'Validation stage has deadlines and competitor dynamics'
-}]->(stage:VentureStage {name: 'Validation'})
-```
-
-### ADDRESSES_PROBLEM_TYPE
-
-Links a Command to ProblemTypes it solves (via multi-hop through Frameworks).
-
-```cypher
-// find-analogies addresses wicked problems (via Design-by-Analogy framework)
-CREATE (cmd:Command {name: '/mos:find-analogies'})-[:ADDRESSES_PROBLEM_TYPE {
-  via_framework: 'Design-by-Analogy',
-  effectiveness: 0.85
-}]->(pt:ProblemType {name: 'wicked'})
-
-// act --swarm addresses complex problems with multiple dimensions
-CREATE (cmd:Command {name: '/mos:act --swarm'})-[:ADDRESSES_PROBLEM_TYPE {
-  via_framework: 'Multiple simultaneous frameworks',
-  effectiveness: 0.90
-}]->(pt:ProblemType {name: 'ill-defined-complex'})
-```
-
-### RESOLVES_TENSION_BETWEEN
-
-Links a Command to Framework pairs that commonly produce contradictions.
-
-```cypher
-// find-analogies resolves tensions between pricing frameworks and competitive positioning
-CREATE (cmd:Command {name: '/mos:find-analogies'})-[:RESOLVES_TENSION_BETWEEN {
-  framework_a: 'Lean Canvas',
-  framework_b: 'Competitive Analysis',
-  resolution_pattern: 'Cross-domain structural isomorphism finds how other industries resolved pricing vs positioning'
-}]->(tension:TensionType {name: 'pricing_vs_positioning'})
-```
-
-## Multi-Hop Proactive Query
-
-The power of this schema is MULTI-HOP reasoning. The Brain can traverse:
-
-```
-User's Room State
-  -> Current Frameworks (from Room artifacts)
-    -> FEEDS_INTO relationships (what comes next)
-      -> Command nodes (which /mos: command delivers it)
-        -> TRIGGERED_BY_SIGNAL (is the trigger condition met?)
-          -> Return ranked command suggestion with full JTBD framing
-```
-
-### Query: brain_proactive_command (Pattern 10d)
-
-```cypher
-// Multi-hop: Room frameworks -> next framework -> command -> trigger check
-MATCH (current:Framework)<-[:FOLLOWS_FRAMEWORK]-(cmd:Command)
-WHERE current.name IN $room_frameworks
-
-// Check if command is relevant at this venture stage
-OPTIONAL MATCH (cmd)-[stage_rel:RELEVANT_AT_STAGE]->(stage:VentureStage {name: $venture_stage})
-
-// Check if command is triggered by current signals
-OPTIONAL MATCH (cmd)-[trigger:TRIGGERED_BY_SIGNAL]->(sig:SignalType)
-
-// Get success data
-OPTIONAL MATCH (current)-[:APPLIED_IN]->(example:Example)
-WHERE example.grade_numeric >= 80
-
-RETURN cmd.name AS command,
-       cmd.jtbd_when AS when_situation,
-       cmd.jtbd_want AS want_motivation,
-       cmd.jtbd_so AS so_outcome,
-       cmd.time_estimate AS time,
-       cmd.flags AS available_flags,
-       stage_rel.impact AS stage_impact,
-       trigger.signal_type AS triggered_by,
-       trigger.condition AS trigger_condition,
-       trigger.jtbd_framing AS trigger_framing,
-       count(example) AS success_count
-ORDER BY stage_rel.impact DESC, trigger.priority ASC, success_count DESC
-LIMIT 5
-```
-
-**Parameters:**
-- `$room_frameworks` -- frameworks used in Room (from artifact frontmatter)
-- `$venture_stage` -- from STATE.md
-
-**Output:** Ranked command suggestions with full JTBD framing, trigger conditions, and success data from real projects.
-
-## Seeding Script
-
-The Command nodes and trigger relationships need to be seeded into Neo4j. Create a script that:
-
-1. Reads all commands/*.md files
-2. Extracts: name, description, allowed-tools, category
-3. Generates JTBD statements from the command's purpose
-4. Creates Command nodes with relationships to:
-   - Frameworks they follow (from methodology chaining rules)
-   - VentureStages they're relevant at (from problem-types.md)
-   - SignalTypes that trigger them (from proactive-intelligence patterns)
-5. Runs the Cypher via `mcp__neo4j-brain__write_neo4j_cypher`
-
-Script location: `scripts/seed-brain-commands.cjs`
-
-## The Intelligence Hierarchy (Updated)
-
-```
-LEVEL 3 (Brain + Room + Signals):
-  brain_proactive_command (Pattern 10d)
-  Multi-hop: frameworks -> commands -> triggers -> JTBD
-  Calibrated from 100+ real projects
-  Knows which sequences ACTUALLY produced results
-
-LEVEL 2 (Room + Local Fabric):
-  Larry's JTBD provoked suggestions (every 3-7 turns)
-  KuzuDB Tensions, Bottlenecks, Surprises, Convergences
-  Good but not cross-venture calibrated
-
-LEVEL 1 (No Room):
-  Generic stage-based defaults
-  methodology/index.md routing table
-  Better than nothing
-```
-
-Brain-connected users get LEVEL 3: the Brain literally tells Larry which command to suggest, when, and why -- backed by data from 100+ real ventures. The JTBD framing is baked into the Command node itself. Larry just reads it and presents it naturally.

package/references/brain/graph-architecture.md

@@ -1,317 +0,0 @@
-# Brain Graph Architecture -- Structural Guide
-
-How the Neo4j Brain is actually wired. Pre-normalization audit 2026-04-06, v1.8.2 normalization executed same day.
-
-## Post-Normalization Metrics (v1.8.2)
-
-```
-Metric                    Before    After    Status
------------------------------------------------
-FEEDS_INTO                    17       47    PASS (target 35+)
-TYPICAL_AT                     4       40    PASS (target 30+)
-ADDRESSES_PROBLEM_TYPE        38       63    PASS (target 50+)
-PREREQUISITE                   0       14    PASS (target 14)
-ALIAS_OF                       0       22    PASS (target 20+)
-TEACHES                        0      370    PASS (target 16+)
-GOVERNS                        0       16    PASS (target 10+)
-GROUNDS_FRAMEWORK              0       24    PASS (target 10+)
-Bot IMPLEMENTS                 0       14    PASS (target 15)
-FrameworkAgent orphans       7/10     0/10   PASS
-LazyGraph orphans             511        0   PASS
-DictionaryTerm duplicates      19        0   PASS
-```
-
-Script: `scripts/v182-brain-optimize.cypher` (19 sections, idempotent)
-
-## The 5-Layer Stack
-
-```
-Layer              Nodes    Purpose                         Key Rels
----------------------------------------------------------------------------
-L1 Curated          281    Hand-built methodology spine     FEEDS_INTO, TYPICAL_AT,
-                           Framework, ProblemType,          ADDRESSES_PROBLEM_TYPE,
-                           VentureStage, ValidationTool,    PREREQUISITE, GOVERNS,
-                           Bot, Workshop, CorePrinciple,    HAS_AGENT, TEACHES,
-                           DeliverableTemplate, CaseStudy   ILLUSTRATES
-
-L2 Document        1,454   Source material chunks           PART_OF (Doc->Chunk),
-                           Document, Chunk, DocumentChunk   FIRST_CHUNK, NEXT_CHUNK
-
-L3 Entity          5,316   Extraction bridge layer          HAS_ENTITY (Chunk->Entity),
-                           __Entity__ (multi-labeled)       RELATES_TO, CLASSIFIES,
-                                                            AUTHORED_BY, HAS_TOPIC
-
-L4 Lazy            8,425   Co-occurrence semantic fabric    CO_OCCURS (245K edges),
-                           LazyGraphConcept                 MENTIONED_IN (->Chunk)
-
-L5 Taxonomy          970   Reference knowledge              INTRODUCES_TERM,
-                           DictionaryTerm, InnovationTool,  ENHANCES_TOOL,
-                           Book, Person, Author             GROUNDS_FRAMEWORK
-
-L6 Runtime         1,449   Usage patterns                   HAD_SESSION,
-                           Session, Problem, Insight,       EXPLORED, DISCOVERED,
-                           Journey, Assumption, User        SUPPORTS
-
-L7 Other           6,183   Mixed/uncategorized              Various
-                           base, Concept, Entity,
-                           ProcessStep, Component, etc.
----------------------------------------------------------------------------
-Total             24,078   (8,534 more in multi-labeled overlap)
-```
-
-## The Critical Structural Insight
-
-**The Lazy layer and the Curated layer have ZERO direct edges between them.**
-
-Confirmed: `MATCH (lgc:LazyGraphConcept)-[r]-(curated) WHERE curated:Framework RETURN count(r)` returns 0.
-
-The only path between them is a 3-hop chain through the Document and Entity layers:
-
-```
-LazyGraphConcept -[MENTIONED_IN]-> Chunk <-[HAS_ENTITY]- __Entity__ -[various]-> Framework
-                                                                     ^
-                                                          Only ~70 edges reach
-                                                          curated nodes here
-```
-
-This means:
-- Any query that tries `(f:Framework)-[:CO_OCCURS]-(lgc)` returns nothing
-- The CO_OCCURS graph is a self-contained semantic network
-- To use Lazy intelligence for Curated decisions, you must bridge through Chunks
-- The ALIAS_OF edges created by normalization scripts partially fix this
-
-## CO_OCCURS Statistics
-
-```
-Total edges:       122,915 (directed, weight property on 99.99%)
-Weight range:      1 - 33
-Distribution:      92% are weight=1 (single co-occurrence)
-                   7.7% are weight 2-5
-                   0.03% are weight 6+ (only 49 edges -- these are STRONG signals)
-No weight:         6 edges (effectively unweighted noise)
-```
-
-**Weight interpretation:** Weight = number of document chunks where both concepts appear.
-Weight >= 6 is a genuinely strong co-occurrence across the teaching corpus.
-
-## LazyGraphConcept Degree Distribution
-
-```
-Total concepts:    8,425
-Orphans (0 rels):    511  (safe to delete)
-Average degree:       29
-Hub threshold:       100+ degree = 751 concepts
-Max degree:        1,367 (concept: "Innovation")
-```
-
-**Top hubs** (most connected in the CO_OCCURS graph):
-- Innovation (1,367), Opportunities (1,070), People (857), Ideas (781)
-- Uncertainty (779), Problems (778), Questions (562)
-- Trending To The Absurd (516) -- this IS a framework name
-- Classroom (439), Creativity (368), Questioning (361)
-
-Hubs above ~400 are generic English words, not PWS-specific.
-Hubs in the 50-200 range are the useful signal layer.
-
-## Entity Bridge Layer
-
-The `__Entity__` layer (5,316 nodes) is the extraction output from document processing. Key facts:
-
-- 732 Entity nodes also carry the `Concept` label
-- 323 also carry `Person`
-- 87 also carry `Book`
-- 19 also carry `Framework` (dirty multi-labeling)
-- 1 carries `ProblemType` (the Wicked Problem canonical node)
-
-**Entity -> Curated bridges** (only ~70 edges):
-- RELATES_TO -> ProblemType: 26 edges
-- CLASSIFIES -> ProblemType: 10 edges
-- HAS -> Framework: 8 edges
-- PART_OF -> Workshop: 8 edges
-- ADDRESSES_PROBLEM_TYPE -> ProblemType/Framework: 13 edges
-- APPLIED_IN -> Framework: 5 edges
-
-This bridge layer is THIN. Most __Entity__ nodes connect only to Chunks (7,718 HAS_ENTITY edges) and to each other.
-
-## Layer Interaction Map
-
-```
-L1 Curated  <--- ~70 edges --->  L3 Entity  <-- 7,718 HAS_ENTITY -->  L2 Document
-     |                                |                                     |
-     | (after normalization:          |                                     |
-     |  ALIAS_OF, GROUNDS_FRAMEWORK)  |                                     |
-     |                                |                               1,183 PART_OF
-     v                                v                                     |
-L5 Taxonomy ---INTRODUCES_TERM-----> L3                              L2 Document
-     |         ENHANCES_TOOL                                               |
-     |                                                              11,935 MENTIONED_IN
-     v                                                                     |
-(after normalization:                                                      v
- GROUNDS_FRAMEWORK -> L1)                                            L4 Lazy
-                                                                   245K CO_OCCURS
-                                                                   (self-contained)
-```
-
-## Practical Query Patterns
-
-### Pattern 1: Curated Layer -- Causal Chain Traversal
-
-Walk the FEEDS_INTO spine from any framework:
-```cypher
-MATCH path = (start:Framework {name: 'Domain Selection'})
-             -[:FEEDS_INTO*1..6]->(end)
-RETURN [n IN nodes(path) | n.name] AS chain, length(path) AS hops
-ORDER BY hops
-```
-
-### Pattern 2: Curated Layer -- Reverse Prerequisite Lookup
-
-What must be completed before a target framework?
-```cypher
-MATCH (target:Framework {name: 'PWS Triple Validation Compass'})
-MATCH (upstream)-[:FEEDS_INTO|PREREQUISITE*1..4]->(target)
-RETURN upstream.name AS prerequisite, labels(upstream)[0] AS type
-```
-
-### Pattern 3: Curated Layer -- Stage-Based Recommendation
-
-What frameworks are appropriate for a venture stage?
-```cypher
-MATCH (stage:VentureStage {name: $venture_stage})
-MATCH (f)-[:TYPICAL_AT]->(stage)
-OPTIONAL MATCH (f)-[:FEEDS_INTO]->(next)
-WHERE NOT (next)-[:TYPICAL_AT]->(stage)
-RETURN f.name AS current_framework, collect(DISTINCT next.name) AS leads_to
-```
-
-### Pattern 4: Curated Layer -- Problem Type Routing
-
-Given a problem classification, which frameworks apply?
-```cypher
-MATCH (pt:ProblemType {name: $problem_type})
-MATCH (f)-[:ADDRESSES_PROBLEM_TYPE]->(pt)
-OPTIONAL MATCH (f)-[:TYPICAL_AT]->(s:VentureStage)
-RETURN f.name AS framework, collect(s.name) AS stages,
-       labels(f)[0] AS type
-ORDER BY size(collect(s.name)) DESC
-```
-
-### Pattern 5: Lazy Layer -- Semantic Neighborhood
-
-Find concepts that co-occur with a target concept (weight >= 2 filters noise):
-```cypher
-MATCH (n:LazyGraphConcept {name: $concept})
-      -[r:CO_OCCURS]->(neighbor:LazyGraphConcept)
-WHERE r.weight >= 2
-RETURN neighbor.name AS concept, r.weight AS strength
-ORDER BY strength DESC
-LIMIT 20
-```
-
-### Pattern 6: Lazy -> Curated Bridge (3-hop)
-
-Find curated Framework nodes semantically related to a lazy concept:
-```cypher
-MATCH (lazy:LazyGraphConcept {name: $concept})
-      -[:MENTIONED_IN]->(chunk:Chunk)
-      <-[:HAS_ENTITY]-(entity:__Entity__)
-WITH entity, count(DISTINCT chunk) AS chunk_support
-WHERE chunk_support >= 2
-MATCH (entity)-[:RELATES_TO|PART_OF|HAS|CLASSIFIES]->(curated)
-WHERE any(l IN labels(curated) WHERE l IN ['Framework','ProblemType'])
-RETURN curated.name AS curated_node, labels(curated)[0] AS type, 
-       chunk_support
-ORDER BY chunk_support DESC
-LIMIT 10
-```
-
-### Pattern 7: ALIAS_OF Traversal (post-normalization)
-
-After running normalization scripts, use ALIAS_OF for ProblemType queries:
-```cypher
-MATCH (pt:ProblemType {name: $problem_type})
-OPTIONAL MATCH (alias)-[:ALIAS_OF]->(pt)
-WITH pt, collect(alias) + [pt] AS all_nodes
-UNWIND all_nodes AS node
-MATCH (node)-[r]-(connected)
-RETURN DISTINCT connected.name, labels(connected)[0], type(r)
-LIMIT 30
-```
-
-### Pattern 8: Full Provenance Chain (post-normalization)
-
-Book -> Framework -> ProblemType with stage context:
-```cypher
-MATCH (b:Book)-[:GROUNDS_FRAMEWORK]->(f:Framework)
-      -[:ADDRESSES_PROBLEM_TYPE]->(pt:ProblemType)
-OPTIONAL MATCH (f)-[:TYPICAL_AT]->(s:VentureStage)
-RETURN b.name AS book, f.name AS framework, 
-       pt.name AS problem_type, collect(s.name) AS stages
-ORDER BY f.name
-```
-
-### Pattern 9: Lazy Concept Promotion Candidates
-
-Find LazyGraphConcepts worth promoting to Concept based on curated proximity:
-```cypher
-MATCH (lgc:LazyGraphConcept)-[:MENTIONED_IN]->(chunk:Chunk)
-      <-[:HAS_ENTITY]-(entity:__Entity__)
-      -[]->(curated)
-WHERE any(l IN labels(curated) WHERE l IN ['Framework','ProblemType','Book'])
-WITH lgc, count(DISTINCT curated) AS curated_links,
-     size([(lgc)-[:CO_OCCURS]-() | 1]) AS co_occurs_degree
-WHERE curated_links >= 2 AND co_occurs_degree >= 20
-RETURN lgc.name AS candidate, curated_links, co_occurs_degree
-ORDER BY curated_links DESC, co_occurs_degree DESC
-LIMIT 30
-```
-
-### Pattern 10: Cross-Domain Discovery via Lazy Layer
-
-Find unexpected connections between two frameworks through CO_OCCURS:
-```cypher
-// First find lazy concepts that bridge to both framework names
-MATCH (lgc1:LazyGraphConcept)-[:MENTIONED_IN]->(c1:Chunk)
-      <-[:HAS_ENTITY]-(e1)-[]->(f1:Framework {name: $framework_a})
-MATCH (lgc1)-[:CO_OCCURS]-(bridge:LazyGraphConcept)-[:CO_OCCURS]-(lgc2:LazyGraphConcept)
-MATCH (lgc2)-[:MENTIONED_IN]->(c2:Chunk)
-      <-[:HAS_ENTITY]-(e2)-[]->(f2:Framework {name: $framework_b})
-WHERE bridge <> lgc1 AND bridge <> lgc2
-RETURN DISTINCT bridge.name AS bridge_concept,
-       lgc1.name AS near_a, lgc2.name AS near_b
-LIMIT 10
-```
-
-## What MindrianOS Uses Each Layer For
-
-| MindrianOS Feature | Primary Layer | Bridge Needed? |
-|---|---|---|
-| /mos:suggest-next | L1 (FEEDS_INTO + TYPICAL_AT) | No |
-| /mos:diagnose | L1 (ADDRESSES_PROBLEM_TYPE) | No |
-| /mos:grade | L1 (Example nodes -- MISSING) | No |
-| /mos:find-connections | L4 (CO_OCCURS) -> L1 | Yes, 3-hop |
-| /mos:find-analogies | L4 (CO_OCCURS) + L1 (ADDRESSES) | Yes, 3-hop |
-| /mos:query (natural language) | L1 + L4 + L5 | Pattern-dependent |
-| /mos:research | External (web) + L5 (Books) | No |
-| /mos:act | L1 (FEEDS_INTO chain) | No |
-| Proactive intelligence | L1 (gap_assess, contradiction_check) | No |
-| Grading calibration | L1 (Example nodes -- MISSING) | No |
-| Meeting filing | L2 (new Chunks) -> L3 -> L4 | Creates new bridges |
-
-## Known Gaps (post-normalization)
-
-1. **Grading calibration data missing:** 0 Example nodes have grade/rubric_scores.
-   Schema.md promises 100+. This is a data loading problem, not a wiring problem.
-
-2. **Lazy-to-Curated bridge is thin:** Only ~70 edges connect __Entity__ to curated
-   nodes. The ALIAS_OF edges from normalization help, but the Entity layer needs
-   enrichment with more RELATES_TO/CLASSIFIES edges.
-
-3. **CO_OCCURS is unweighted for 92% of edges:** Weight=1 means "appeared in same
-   chunk once." Only 49 edges have weight >= 6. The semantic signal is sparse.
-
-4. **511 orphan LazyGraphConcepts:** Safe to delete but not yet cleaned.
-
-5. **The "Other" layer (6,183 nodes):** Uncategorized Concept, Entity, ProcessStep,
-   Component, base nodes. Many are useful but unlabeled relative to MindrianOS
-   taxonomy. Future work: classify and promote valuable ones.