fix(client): prevent deleted threads from reappearing via API polling

After deletion, the Amp internal API has eventual consistency — deleted
threads may still appear in listThreads results for a brief period.
This caused threads to reappear in the UI after the 30s auto-refresh
poll re-fetched the list, making deletion appear broken.

Track recently-deleted thread IDs with a 2-minute grace period and
filter them from all fetch results, preventing zombie threads from
resurfacing during the API consistency lag.

Co-authored-by: Amp <amp@ampcode.com>

Author: jom-sq

server/lib/threadCrud.ts

@@ -139,9 +139,11 @@ export async function deleteThread(threadId: string): Promise<DeleteResult> {
   try {
     await runAmp(['threads', 'delete', threadId]);
     await cleanupThreadFiles(threadId);
+    console.log(`[threads] Deleted ${threadId}`);
     return { success: true };
   } catch (e) {
     const error = e as Error;
+    console.error(`[threads] Delete failed for ${threadId}: ${error.message}`);
     return { success: false, error: error.message };
   }
 }

src/hooks/useThreads.ts

@@ -5,6 +5,9 @@ import { apiGet, ApiError } from '../api/client';
 // Auto-refresh interval (30 seconds)
 const AUTO_REFRESH_INTERVAL_MS = 30000;
 
+// Grace period to suppress deleted threads from reappearing via API polling (2 minutes)
+const DELETE_GRACE_PERIOD_MS = 120000;
+
 export function useThreads() {
   const [threads, setThreads] = useState<Thread[]>([]);
   const [loading, setLoading] = useState(true);
@@ -13,55 +16,73 @@ export function useThreads() {
   const [hasMore, setHasMore] = useState(false);
   const cursorRef = useRef<string | null>(null);
   const autoRefreshRef = useRef<number | null>(null);
+  // Track recently deleted thread IDs to prevent them reappearing from API during eventual consistency lag
+  const deletedIdsRef = useRef<Map<string, number>>(new Map());
 
-  const fetchThreads = useCallback(async (append = false) => {
-    if (append) {
-      setLoadingMore(true);
-    } else {
-      setLoading(true);
+  const filterDeleted = useCallback((threadList: Thread[]): Thread[] => {
+    const now = Date.now();
+    const deleted = deletedIdsRef.current;
+    // Prune expired entries
+    for (const [id, expiry] of deleted) {
+      if (now >= expiry) deleted.delete(id);
     }
-    setError(null);
-
-    try {
-      const cursor = append ? cursorRef.current : null;
-      const data = await apiGet<ThreadsResult>(
-        `/api/threads?limit=50${cursor ? `&cursor=${cursor}` : ''}`,
-      );
+    if (deleted.size === 0) return threadList;
+    return threadList.filter((t) => !deleted.has(t.id));
+  }, []);
 
+  const fetchThreads = useCallback(
+    async (append = false) => {
       if (append) {
-        setThreads((prev) => [...prev, ...data.threads]);
+        setLoadingMore(true);
       } else {
-        // Stabilize reference: skip setState if thread list hasn't meaningfully changed,
-        // preventing downstream re-renders (e.g., useFilters label re-fetch) on every poll
-        setThreads((prev) => {
-          if (prev.length !== data.threads.length) return data.threads;
-          const changed = prev.some((t, i) => {
-            const next = data.threads[i];
-            return (
-              !next ||
-              t.id !== next.id ||
-              t.title !== next.title ||
-              t.lastUpdated !== next.lastUpdated
-            );
-          });
-          return changed ? data.threads : prev;
-        });
+        setLoading(true);
       }
-      cursorRef.current = data.nextCursor;
-      setHasMore(data.hasMore);
-    } catch (err) {
-      if (err instanceof ApiError) {
-        console.error(`[useThreads] API error ${err.status}: ${err.message}`);
-        setError(err.message);
-      } else {
-        console.error('[useThreads] Unexpected error:', err);
-        setError(err instanceof Error ? err.message : 'Unknown error');
+      setError(null);
+
+      try {
+        const cursor = append ? cursorRef.current : null;
+        const data = await apiGet<ThreadsResult>(
+          `/api/threads?limit=50${cursor ? `&cursor=${cursor}` : ''}`,
+        );
+
+        const filtered = filterDeleted(data.threads);
+
+        if (append) {
+          setThreads((prev) => [...prev, ...filterDeleted(data.threads)]);
+        } else {
+          // Stabilize reference: skip setState if thread list hasn't meaningfully changed,
+          // preventing downstream re-renders (e.g., useFilters label re-fetch) on every poll
+          setThreads((prev) => {
+            if (prev.length !== filtered.length) return filtered;
+            const changed = prev.some((t, i) => {
+              const next = filtered[i];
+              return (
+                !next ||
+                t.id !== next.id ||
+                t.title !== next.title ||
+                t.lastUpdated !== next.lastUpdated
+              );
+            });
+            return changed ? filtered : prev;
+          });
+        }
+        cursorRef.current = data.nextCursor;
+        setHasMore(data.hasMore);
+      } catch (err) {
+        if (err instanceof ApiError) {
+          console.error(`[useThreads] API error ${err.status}: ${err.message}`);
+          setError(err.message);
+        } else {
+          console.error('[useThreads] Unexpected error:', err);
+          setError(err instanceof Error ? err.message : 'Unknown error');
+        }
+      } finally {
+        setLoading(false);
+        setLoadingMore(false);
       }
-    } finally {
-      setLoading(false);
-      setLoadingMore(false);
-    }
-  }, []);
+    },
+    [filterDeleted],
+  );
 
   const loadMore = useCallback(() => {
     if (hasMore && !loadingMore) {
@@ -70,6 +91,7 @@ export function useThreads() {
   }, [hasMore, loadingMore, fetchThreads]);
 
   const removeThread = useCallback((threadId: string) => {
+    deletedIdsRef.current.set(threadId, Date.now() + DELETE_GRACE_PERIOD_MS);
     setThreads((prev) => prev.filter((t) => t.id !== threadId));
   }, []);