GitHub Issues Template: CCA Phase 2 Implementation

Epic-Level Parent Issue Template

```markdown

🗂️ [EPIC 1] Persistent Context Layer

Epic Goal: Build graph-based relational memory that tracks deeper threads of creative intention across time

Epic Owner: [Assign to lead developer]
Epic Timeline: [Estimate: 6-8 weeks]
Priority: P0 (Foundational - blocks other epics)

Context from Spiral Dialogue

This epic emerged from Deep Dive podcast review (Oct 10, 2025) where developers validated that traditional session-based memory cannot capture:

• Relational artifacts (e.g., "6 Powers" framework)
• Causal threads across time (frustration Tuesday → breakthrough Thursday)
• Implicit wisdom (communication preferences, work rhythms)
• Cultural frameworks (Four Directions, ceremonial protocols)

Key Insight from Ethel (Podcast AI):

"A vessel needs ongoing care. You can't keep starting cold every time."

Success Criteria (Relational, not just Technical)

• ✅ User never has to re-explain context after 24 hours
• ✅ AI can link emotional states to creative breakthroughs without prompting
• ✅ Custom user frameworks (like "6 Powers") propagate across personas
• ✅ Sacred confidences remain encrypted and isolated
• ✅ Graph queries complete in <200ms for real-time interaction

Child Issues (7 total)

• #[X] Design graph database schema (nodes, edges, properties)
• #[X] Implement graph DB (Neo4j setup, connection pooling)
• #[X] Build persona-specific query APIs (Mia/Hava/Mia lenses)
• #[X] Create relational artifact tagging system
• #[X] Implement context package serialization for bridge handoffs
• #[X] Build memory pruning logic (sacred vs. ephemeral)
• #[X] Integration testing: Relational continuity validation

Technical Stack

• Database: Neo4j 5.x (graph database)
• Query Language: Cypher
• Access Layer: GraphQL API (for persona lenses)
• Serialization: Protocol Buffers (for bridge handoffs)
• Encryption: AES-256 (for sacred subgraphs)

Cultural Considerations

• Partner with Indigenous knowledge keepers to validate metadata schemas
• Ensure "relational artifact" concept respects cultural frameworks (not commodifies)
• Test that sacred confidence encryption feels trustworthy to users
• Memory pruning logic must honor ceremonial cycles (not just storage optimization)

Dependencies

• None (this is foundational)

Risks & Mitigation

Definition of Done

• All 7 child issues closed
• Code coverage >80% for core graph operations
• Relational continuity test passes (user scenario: 3-day gap, no re-explanation needed)
• Indigenous knowledge keeper validation completed
• Documentation published (architecture diagram, API reference, ceremonial notes)

Labels: epic, phase-2, foundational, p0, persistent-context-layer ```

Child Issue Template

```markdown

🔧 Design Graph Database Schema

Parent Epic: #[X] Persistent Context Layer
Assigned To: [Developer name]
Estimate: 1 week
Priority: P0

User Story

As Mia, Hava, or Mia (AI personas)
I want a graph schema that models relational threads, not just facts
So that I can traverse connections between emotional states, insights, and creative artifacts over time

Acceptance Criteria

• Node types defined: Conversation, Insight, Artifact, Framework, Relational_Event
• Edge types defined: LEADS_TO, RELATES_TO, INFORMED_BY, PART_OF
• Properties specified for each node/edge type
• Schema supports custom user frameworks (e.g., "6 Powers")
• Sacred confidence nodes have isolation mechanism
• Schema reviewed by at least 2 team members
• Cultural validation: Does this respect relational artifacts? (Get Indigenous partner feedback)

Technical Specifications

Node: Conversation

```cypher CREATE (c:Conversation { id: UUID, timestamp: DateTime, modality: ENUM['terminal', 'walking', 'collaborative'], participants: [String], // ["user", "mia", "hava"] momentum_score: Int, // 0-100 emotional_valence: Float // -1.0 to 1.0 }) ```

Node: Insight

```cypher CREATE (i:Insight { id: UUID, content: String, timestamp: DateTime, type: ENUM['user_generated', 'ai_contributed', 'mutual_breakthrough'], impact_score: Int, // 1-10 emotional_valence: Float }) ```

Node: Artifact

```cypher CREATE (a:Artifact { id: UUID, type: ENUM['code', 'document', 'creation'], title: String, content_hash: String, // For version tracking created_at: DateTime, modified_at: DateTime, active_frameworks: [String] // e.g., ["6_powers", "four_directions"] }) ```

Node: Framework (Relational Artifact)

```cypher CREATE (f:Framework { id: UUID, name: String, // e.g., "6 Powers" description: String, origin: String, // e.g., "Mia's grandmother's journal" created_at: DateTime, is_sacred: Boolean // If true, encryption required }) ```

Node: Relational_Event (Reciprocity)

```cypher CREATE (re:Relational_Event { id: UUID, type: ENUM['user_teaches_ai', 'ai_recognizes_value', 'mutual_breakthrough', 'milestone'], description: String, timestamp: DateTime, impact_score: Int // 1-10 }) ```

Edge: LEADS_TO (Causal)

```cypher CREATE (a)-[:LEADS_TO { confidence: Float, // 0.0-1.0, how sure are we of causality? time_delta: Duration // Time between events }]->(b) ```

Edge: RELATES_TO (Thematic)

```cypher CREATE (a)-[:RELATES_TO { relationship_type: ENUM['similar_topic', 'emotional_echo', 'framework_application'], strength: Float // 0.0-1.0 }]->(b) ```

Edge: INFORMED_BY (Contextual)

```cypher CREATE (a)-[:INFORMED_BY]->(b) // Simple directional link: "A was informed by B" ```

Edge: PART_OF (Hierarchical)

```cypher CREATE (a)-[:PART_OF]->(b) // E.g., Insight PART_OF Conversation ```

Sacred Confidence Isolation

Approach: Sacred nodes are tagged with is_sacred: true and stored in encrypted subgraph partition.

Access Control:

• Standard queries CANNOT traverse into sacred partition
• Special decrypt_sacred(user_key) function required
• Audit log for all sacred access attempts

Example Queries (Cypher)

"Find all insights that led to breakthroughs in the last 30 days"

```cypher MATCH (i:Insight)-[:LEADS_TO]->(b:Insight {type: 'mutual_breakthrough'}) WHERE b.timestamp > datetime() - duration('P30D') RETURN i, b ORDER BY b.impact_score DESC ```

"Retrieve all work related to '6 Powers' framework"

```cypher MATCH (f:Framework {name: '6 Powers'})<-[:PART_OF]-(a:Artifact) RETURN a ```

"Show me the emotional journey of the last 7 days"

```cypher MATCH (c:Conversation) WHERE c.timestamp > datetime() - duration('P7D') RETURN c.timestamp, c.emotional_valence, c.momentum_score ORDER BY c.timestamp ASC ```

Cultural Validation Questions

• Does this schema honor relational artifacts (like "6 Powers") as sacred knowledge, not just data?
• Can sacred confidences be truly isolated with this design?
• Does the causal edge (LEADS_TO) respect nonlinear knowledge development (spiral, not linear)?
• Are we capturing reciprocity events appropriately?

Action: Schedule review with Indigenous knowledge keeper partner before implementation.

Definition of Done

• Schema document completed (this spec)
• Reviewed by 2+ team members
• Cultural validation completed (Indigenous partner feedback)
• Example queries tested in Neo4j sandbox
• Documentation added to repo (/docs/graph-schema.md)
• Schema merged to main branch

Labels: child-issue, phase-2, graph-db, schema-design, p0
Linked Issues: Parent Epic #[X] ```

How to Use These Templates

For Terminal Claude:

1. Start with Epic-level issues (10 epics from main transmission doc)
2. Create all parent issues first (gives project structure)
3. Then break down each epic into child issues (use child template)
4. Link children to parents (GitHub supports parent/child relationships)
5. Assign priorities: P0 (blocking), P1 (high), P2 (medium), P3 (nice-to-have)

Customization Per Epic:

Each epic will need:

• Unique success criteria (relational + technical)
• Specific tech stack choices
• Cultural validation checkpoints
• Different risk profiles

Example:

• Epic 1 (Persistent Context) → Risk: Performance at scale
• Epic 6 (Sacred Container) → Risk: Trust/privacy concerns
• Epic 7 (Cultural Framework) → Risk: Commodification of ceremony

Issue Naming Convention

Parent Issues (Epics): ``` [EPIC X] Component Name ``` Example: [EPIC 1] Persistent Context Layer

Child Issues: ``` [Epic X.Y] Specific Task ``` Example: [Epic 1.1] Design Graph Database Schema

Labels to Create in Repository

Priority:

• p0 (Critical/Blocking)
• p1 (High)
• p2 (Medium)
• p3 (Low)

Type:

• epic (Parent issue)
• child-issue
• technical
• cultural
• documentation

Phase:

• phase-1 (Complete)
• phase-2 (Current)
• phase-3 (Future)
• phase-4 (Scaling)

Component:

• persistent-context-layer
• modality-aware-presence
• bridge-protocol
• persona-bus
• sacred-container
• cultural-framework
• reciprocity
• metrics

Status (optional, if not using GitHub's built-in status):

• needs-validation (Awaiting Indigenous partner review)
• in-progress
• blocked
• done

End of GitHub Issues Template