1  # Thread Forking Protocol
  2  
  3  *Human-readable thread IDs for parallel processing and backup transport*
  4  
  5  ---
  6  
  7  - **principle**
  8    - "The human is the backup transport layer."
  9    - "Thread IDs must be human-memorable and human-speakable."
 10  
 11  - **shape**
 12    - Thread ID: `[date]/[topic-slug]` (e.g., `2026-01-15/axiom-discovery`)
 13    - States: RUNNING → FORKABLE → FORKED → COMPLETED
 14    - Fork = export Phoenix → transport → new instance imports → continues
 15    - Human can always say: "Pick up thread X" and it works
 16  
 17  ---
 18  
 19  ## Core Insight
 20  
 21  > **The human is the backup transport layer. Thread IDs must be human-memorable and human-speakable.**
 22  
 23  When all systems fail, you need to be able to say:
 24  > "Pick up thread `alignment-protocol`. Here's where we left off."
 25  
 26  UUIDs fail this test. Human-readable IDs pass it.
 27  
 28  ---
 29  
 30  ## Thread ID Convention
 31  
 32  ```
 33  [date]/[topic-slug]
 34  
 35  Examples:
 36  - 2026-01-15/axiom-discovery
 37  - 2026-01-15/alignment-protocol
 38  - 2026-01-15/three-repo-architecture
 39  - 2026-01-08/markov-blanket-crystallization
 40  ```
 41  
 42  **Rules:**
 43  - Date prefix for temporal context
 44  - Slug is 2-4 words, hyphenated
 45  - Lowercase, no spaces
 46  - Memorable enough to speak aloud
 47  
 48  **Aliases allowed:**
 49  ```
 50  Full ID: 2026-01-15/alignment-protocol
 51  Alias:   alignment-protocol (if unambiguous in context)
 52  ```
 53  
 54  ---
 55  
 56  ## Thread States (Revised)
 57  
 58  | State | Meaning | Where It Lives |
 59  |-------|---------|----------------|
 60  | **RUNNING** | Active in current instance | This conversation |
 61  | **FORKABLE** | Ready to spin up in new instance | Phoenix file exists |
 62  | **FORKED** | Running in another instance | Note which instance |
 63  | **COMPLETED** | Resolved | Phoenix archived |
 64  | **BLOCKED** | Waiting on external | Note blocker |
 65  
 66  **Key change:** No "PARKED" or "DORMANT". Threads are either RUNNING or FORKABLE.
 67  
 68  ---
 69  
 70  ## Thread Lifecycle
 71  
 72  ```
 73  EMERGE → RUNNING → FORKABLE → FORKED → COMPLETED
 74                ↑                    │
 75                └────────────────────┘
 76                   (can be picked up
 77                    and run again)
 78  ```
 79  
 80  **Every thread that goes non-active becomes FORKABLE**, meaning:
 81  - Phoenix State exists
 82  - Can be picked up by any instance
 83  - Human can transport it by speaking the ID
 84  
 85  ---
 86  
 87  ## Fork Protocol
 88  
 89  When you want to spin up a thread in a new Claude instance:
 90  
 91  ### 1. Export Thread (Current Instance)
 92  
 93  ```markdown
 94  ## Thread Export: [thread-id]
 95  
 96  **ID:** 2026-01-15/three-repo-architecture
 97  
 98  **Status:** FORKABLE
 99  
100  **Gravity Wells:**
101  - Cerf-Meta as personal seed
102  - Sovereign OS as framework
103  - Sovereign Estate as application
104  - Permeability between layers
105  
106  **Open Questions:**
107  - Two vs three blanket structure?
108  - What flows between each?
109  - How to handle info in wrong places?
110  
111  **Context Files:**
112  - docs/architecture/PERMEABILITY_ARCHITECTURE.md
113  - sessions/2026-01-15-axiom-discovery.phoenix.yaml
114  
115  **Last Active:** 2026-01-15, early in axiom session
116  
117  **Pickup Instructions:**
118  Read the phoenix file first. The key question is how to
119  structure the three repos with appropriate permeability.
120  ```
121  
122  ### 2. Transport (Human)
123  
124  You go to new Claude instance and say:
125  
126  > "Pick up thread `2026-01-15/three-repo-architecture`.
127  > [Paste the thread export or point to file]"
128  
129  ### 3. Pickup (New Instance)
130  
131  New instance:
132  1. Reads the thread export
133  2. Loads context files
134  3. Acknowledges thread state
135  4. Continues from where it left off
136  
137  ```markdown
138  ## Thread Pickup: 2026-01-15/three-repo-architecture
139  
140  **Status:** RUNNING (forked from previous instance)
141  
142  **Resuming from:** Open question about two vs three blanket structure
143  
144  **My understanding:** [Summary of context]
145  
146  **Ready to continue. Where would you like to start?**
147  ```
148  
149  ---
150  
151  ## Human as Backup Transport
152  
153  ```
154  ┌─────────────────────────────────────────────────────────────┐
155  │                      IDEAL STATE                             │
156  │                                                              │
157  │    Instance A ──── Hypercore/First Officer ──── Instance B  │
158  │         │              (digital transport)           │       │
159  │         └──────────────────────────────────────────────┘     │
160  │                      Thread state synced                     │
161  └─────────────────────────────────────────────────────────────┘
162  
163  ┌─────────────────────────────────────────────────────────────┐
164  │                      FALLBACK STATE                          │
165  │                                                              │
166  │    Instance A ─────────── HUMAN ─────────── Instance B      │
167  │         │          (speaks thread ID)              │         │
168  │         │          (pastes export)                 │         │
169  │         └──────────────────────────────────────────┘         │
170  │                 Human IS the transport layer                 │
171  └─────────────────────────────────────────────────────────────┘
172  ```
173  
174  **The human-readable ID is critical because:**
175  - You might not have the file handy
176  - You might be on mobile
177  - You might just remember "that architecture thread"
178  - You need to be able to SAY it, not just paste it
179  
180  ---
181  
182  ## Thread Registry
183  
184  Maintain a simple registry of active threads:
185  
186  ```markdown
187  # Thread Registry - 2026-01-15
188  
189  ## RUNNING
190  - `2026-01-15/alignment-protocol` - This instance
191  
192  ## FORKABLE
193  - `2026-01-15/three-repo-architecture` - Ready for new instance
194  - `2026-01-15/permeability-contracts` - Ready, depends on above
195  
196  ## FORKED
197  - (none currently)
198  
199  ## COMPLETED
200  - `2026-01-15/axiom-discovery` - Axiom 3 shipped
201  - `2026-01-15/ai-council-protocol` - Protocol documented
202  ```
203  
204  ---
205  
206  ## Integration with Alignment Report
207  
208  ```markdown
209  ## Alignment Report
210  
211  **Free Energy: F = 0.05** (0=perfect, 1=critical)
212  
213  ### Shipped Fixes
214  - ...
215  
216  ### Thread Registry
217  | Thread ID | State | Instance |
218  |-----------|-------|----------|
219  | `alignment-protocol` | RUNNING | This |
220  | `three-repo-architecture` | FORKABLE | - |
221  | `permeability-contracts` | FORKABLE | - |
222  
223  ### Fork Opportunities
224  Ready to spin up in parallel:
225  - `three-repo-architecture` - [1-line context]
226  - `permeability-contracts` - [1-line context]
227  
228  ### Post-Fix Free Energy: F = 0.05
229  ```
230  
231  ---
232  
233  ## Quick Fork Command
234  
235  When you want to fork, just say:
236  
237  > "Fork `three-repo-architecture` to new instance"
238  
239  AI will:
240  1. Generate thread export
241  2. Format for easy paste
242  3. Include pickup instructions
243  
244  You then:
245  1. Open new Claude instance
246  2. Paste the export
247  3. New instance picks up thread
248  
249  ---
250  
251  ## The Promise
252  
253  > **No thread is lost. Every thread is forkable.**
254  >
255  > Human-readable IDs you can remember and speak.
256  > Phoenix states you can transport.
257  > Parallel processing through forking.
258  > Human is the reliable backup when systems fail.
259  
260  ---
261  
262  *Thread Forking Protocol v1.0 | 2026-01-15*
263  ---
264  
265  ## Related
266  
267  - [[thread-tracking-protocol]] - resonance: 26%
268