feat(edit): implement synchronous indexing for edit chain resolution and enhance edit tracking in tests

Author: i5heu

frontend/src/routes/+page.svelte

@@ -630,6 +630,64 @@
 	};
 
 	const upsertNodeFromStream = (node: ThreadNodePayload) => {
+		// If this node is an edit of another message, do NOT display it separately.
+		// Instead, update the original message to point to this edit, and register
+		// the edit key so subsequent edits in the chain can find the original.
+		// EXCEPTION: If messages is empty, this is the first/root node being streamed
+		// (e.g., from a search selection), so we should display it even if it's an edit.
+		if (node.editOf && messages.length > 0) {
+			// Walk the edit chain to find the original (non-edit) message
+			let originalKey = node.editOf;
+			let visited = new Set<string>();
+			while (originalKey && !visited.has(originalKey)) {
+				visited.add(originalKey);
+				const path = keyToPath.get(originalKey);
+				if (path) {
+					const msg = getMessageAtPath(messages, path);
+					if (msg && msg.editOf) {
+						// This message is itself an edit, keep walking back
+						originalKey = msg.editOf;
+					} else {
+						// Found the original message
+						break;
+					}
+				} else {
+					break;
+				}
+			}
+
+			const originalPath = keyToPath.get(originalKey);
+			if (originalPath) {
+				updateMessageAtPath(originalPath, (message) => {
+					// Update the original message with the edit's content metadata
+					message.mimeType = node.mimeType;
+					message.isText = node.isText;
+					message.sizeBytes = node.sizeBytes;
+					// Keep original createdAt to preserve position in sort order
+					if (node.computedId) {
+						message.computedId = node.computedId;
+					}
+					// Track that this message has been edited and store the edit key
+					message.suggestedEdit = node.key;
+					message.resolvedKey = node.key;
+					if (node.title) {
+						message.title = node.title;
+						if (!message.attachmentName) {
+							message.attachmentName = node.title;
+						}
+					}
+				});
+				// Register the edit key to point to the original's path
+				if (node.key) {
+					keyToPath.set(node.key, originalPath);
+				}
+				requestMessageHydration(node);
+				return;
+			}
+			// If original not found, skip this edit entirely - don't create a duplicate
+			return;
+		}
+
 		const existingPath = node.key ? keyToPath.get(node.key) : undefined;
 		if (existingPath) {
 			updateMessageAtPath(existingPath, (message) => {
@@ -1076,24 +1134,37 @@
 		if (!node.key) {
 			return;
 		}
-		const cached = await readCachedMessageRecord(node.key);
+		// Use suggestedEdit key if available - this points to the latest edit content
+		const hydrateKey = node.suggestedEdit || node.key;
+
+		// Map the hydration key to the original's path BEFORE hydrating,
+		// so when the result comes back, applyRecordToMessage can find it
+		if (hydrateKey !== node.key) {
+			const path = keyToPath.get(node.key);
+			if (path) {
+				keyToPath.set(hydrateKey, path);
+			}
+		}
+
+		const cached = await readCachedMessageRecord(hydrateKey);
 		if (cached) {
-			applyRecordToMessage(cached);
+			applyRecordToMessage({ ...cached, key: node.key });
 			return;
 		}
 		// For text nodes, we hydrate via the bulk worker (it will provide content
 		// and metadata). For non-text nodes we avoid downloading the full payload
 		// (could be large) and instead perform a small Range fetch to get headers
 		// such as X-Ouroboros-Title.
 		if (node.isText) {
-			await enqueueBulkHydration(node.key);
+			await enqueueBulkHydration(hydrateKey);
 			return;
 		}
 		try {
-			const record = await fetchMessageMetadata(node);
+			const record = await fetchMessageMetadata({ ...node, key: hydrateKey });
 			if (record) {
+				// Store with the hydrate key but apply to the original message
 				persistMessageRecord(record);
-				applyRecordToMessage(record);
+				applyRecordToMessage({ ...record, key: node.key });
 			}
 		} catch (error) {
 			console.warn('Failed to fetch message metadata', error);
@@ -1263,6 +1334,14 @@
 				if (node.key) {
 					map.set(node.key, current);
 				}
+				// Also map suggestedEdit and resolvedKey to the same path,
+				// so hydration results from edit keys can find the original message
+				if (node.suggestedEdit && node.suggestedEdit !== node.key) {
+					map.set(node.suggestedEdit, current);
+				}
+				if (node.resolvedKey && node.resolvedKey !== node.key) {
+					map.set(node.resolvedKey, current);
+				}
 				traverse(node.children, current);
 			});
 		};
@@ -1953,7 +2032,10 @@
 			mime_type: mimeType,
 			is_text: true,
 			filename: 'message.txt',
-			edit_of: target.key
+			// Use resolvedKey or suggestedEdit if available - this ensures edits form
+			// a chain (Test1 → Test2 → Test3 → Test4) rather than all pointing to the
+			// original (Test1 ← Test2, Test1 ← Test3, Test1 ← Test4).
+			edit_of: target.resolvedKey || target.suggestedEdit || target.key
 		};
 		if (target.parentKey) {
 			metadata.parent = target.parentKey;
@@ -1996,7 +2078,15 @@
 
 			const updated = getMessageAtPath(messages, editTargetPath);
 			if (updated && updated.key) {
-				persistMessageRecord(messageToRecord(updated));
+				// Cache with both the original key AND the new edit key.
+				// On reload, we'll hydrate using suggestedEdit (the new key),
+				// so it needs to be in the cache.
+				const record = messageToRecord(updated);
+				persistMessageRecord(record);
+				if (key && key !== updated.key) {
+					// Also cache under the new edit key so hydration can find it
+					persistMessageRecord({ ...record, key: key });
+				}
 			}
 
 			statusState = 'success';
@@ -2739,6 +2829,7 @@
 		top: 0;
 		background: var(--surface-raised);
 		padding: 0.75rem;
+		z-index: 100;
 	}
 
 	.conversation-header h1 {

ouroboros.go

@@ -316,11 +316,14 @@ func (ou *OuroborosDB) StoreData(ctx context.Context, content []byte, opts Store
 		return hash.Hash{}, err
 	}
 
-	// After successful write, index the new data asynchronously if indexer is present.
+	// After successful write, index the new data. This must be synchronous
+	// so that edit chain resolution works correctly on subsequent reads.
+	// Previously this was async which caused race conditions where the index
+	// wasn't updated in time for reload requests.
 	if ou.indexer != nil {
-		go func(h hash.Hash) {
-			_ = ou.indexer.IndexHash(h)
-		}(dataHash)
+		if err := ou.indexer.IndexHash(dataHash); err != nil && ou.log != nil {
+			ou.log.Warn("failed to index new data", "error", err, "key", dataHash.String())
+		}
 	}
 
 	return dataHash, nil

ouroboros_test.go

@@ -240,6 +240,106 @@ func TestGetDataSuggestsLatestEdit(t *testing.T) {
 	}
 }
 
+func TestGetDataSuggestsLatestEditChained(t *testing.T) {
+	testDir := setupTestDir(t)
+	t.Cleanup(func() { cleanupTestDir(t, testDir) })
+
+	setupTestKeyFile(t, testDir)
+	cfg := Config{Paths: []string{testDir}, MinimumFreeGB: 1, Logger: testLogger()}
+	db, err := New(cfg)
+	if err != nil {
+		t.Fatalf("new db: %v", err)
+	}
+	if err := db.Start(context.Background()); err != nil {
+		t.Fatalf("start db: %v", err)
+	}
+	defer func() { _ = db.CloseWithoutContext() }()
+
+	// Create original message (Test1)
+	test1Content := []byte("Test1")
+	test1Key, err := db.StoreData(context.Background(), test1Content, StoreOptions{MimeType: "text/plain; charset=utf-8"})
+	if err != nil {
+		t.Fatalf("store test1: %v", err)
+	}
+	time.Sleep(10 * time.Millisecond)
+
+	// Edit Test1 -> Test2
+	test2Content := []byte("Test2")
+	test2Key, err := db.StoreData(context.Background(), test2Content, StoreOptions{
+		MimeType: "text/plain; charset=utf-8",
+		EditOf:   test1Key,
+	})
+	if err != nil {
+		t.Fatalf("store test2: %v", err)
+	}
+	time.Sleep(10 * time.Millisecond)
+
+	// Edit Test2 -> Test3
+	test3Content := []byte("Test3")
+	test3Key, err := db.StoreData(context.Background(), test3Content, StoreOptions{
+		MimeType: "text/plain; charset=utf-8",
+		EditOf:   test2Key,
+	})
+	if err != nil {
+		t.Fatalf("store test3: %v", err)
+	}
+	time.Sleep(10 * time.Millisecond)
+
+	// Edit Test3 -> Test10
+	test10Content := []byte("Test10")
+	test10Key, err := db.StoreData(context.Background(), test10Content, StoreOptions{
+		MimeType: "text/plain; charset=utf-8",
+		EditOf:   test3Key,
+	})
+	if err != nil {
+		t.Fatalf("store test10: %v", err)
+	}
+
+	// Force index updates so edit resolution is available synchronously.
+	idx := db.Indexer()
+	if idx != nil {
+		for _, k := range []cryptHash.Hash{test1Key, test2Key, test3Key, test10Key} {
+			if err := idx.IndexHash(k); err != nil {
+				t.Fatalf("index %s: %v", k.String(), err)
+			}
+		}
+	}
+
+	// Verify the edit chain resolves correctly from Test1 to Test10
+	resolved, changed := db.resolveLatestEdit(test1Key)
+	if !changed || resolved != test10Key {
+		t.Fatalf("expected resolveLatestEdit(test1) to return test10 %s, got %s (changed=%v)",
+			test10Key.String(), resolved.String(), changed)
+	}
+
+	// Verify GetData on test1 returns suggestedEdit pointing to test10
+	data, err := db.GetData(context.Background(), test1Key)
+	if err != nil {
+		t.Fatalf("get data: %v", err)
+	}
+	if data.SuggestedEdit.IsZero() || data.SuggestedEdit != test10Key {
+		t.Fatalf("expected suggested edit %s, got %s", test10Key.String(), data.SuggestedEdit.String())
+	}
+
+	// Verify the original content is returned (not the edit content)
+	if string(data.Content) != string(test1Content) {
+		t.Fatalf("expected original content %q, got %q", string(test1Content), string(data.Content))
+	}
+
+	// Verify that intermediate edits also resolve to test10
+	resolvedFrom2, _ := db.resolveLatestEdit(test2Key)
+	if resolvedFrom2 != test10Key {
+		t.Fatalf("expected resolveLatestEdit(test2) to return test10 %s, got %s",
+			test10Key.String(), resolvedFrom2.String())
+	}
+
+	resolvedFrom3, _ := db.resolveLatestEdit(test3Key)
+	if resolvedFrom3 != test10Key {
+		t.Fatalf("expected resolveLatestEdit(test3) to return test10 %s, got %s",
+			test10Key.String(), resolvedFrom3.String())
+	}
+}
+
 func TestNewOuroborosDB_WithDefaultLogger(t *testing.T) { // A
 	testDir := setupTestDir(t)
 	t.Cleanup(func() { cleanupTestDir(t, testDir) })

pkg/apiServer/meta.go

@@ -249,10 +249,13 @@ func (s *Server) handleThreadNodeStream(w http.ResponseWriter, r *http.Request)
 				return baseData.SuggestedEdit.String()
 			}(),
 			EditOf: func() string {
-				if nodeData.EditOf.IsZero() {
+				// Use baseData.EditOf, not nodeData.EditOf, because we want to know
+				// if THIS node (by its original key) is an edit, not whether the
+				// suggested edit content is an edit of something else.
+				if baseData.EditOf.IsZero() {
 					return ""
 				}
-				return nodeData.EditOf.String()
+				return baseData.EditOf.String()
 			}(),
 		}
 		if !nodeData.CreatedAt.IsZero() {