fix(client): thread deletion fixes and load all available threads (#77)

jom-sq · ampcode-com · web-flow · commit 126cf2234a13 · 2026-04-09T10:00:12.000-04:00
* 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 &lt;amp@ampcode.com&gt;

* fix(client): load all available threads instead of first 50

The client was requesting only 50 threads from the server, but the
server fetches up to 500 from the Amp API. This meant users with many
threads only saw ~42 entries (50 minus stacked children), and deleting
a thread appeared to have no effect on the count because a previously-
hidden thread would backfill into the 50-thread window.

Now requests limit=500 to match the server's Amp API cap, showing all
available threads. The Amp API hard-caps at 500 — no pagination support
— so this is the maximum we can display.

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* fix: paginate Amp API to load 1000 threads, stop premature refetch on bulk ops

Three changes:

1. Paginate the Amp listThreads API using offset to fetch up to 1000
   threads (the API caps at 500 per request). Previously only the
   first 500 were loaded.

2. Move refetch() in bulk delete/archive to only fire on failure.
   Previously refetch() ran unconditionally after bulk operations,
   which would immediately re-fetch the full list and undo the
   optimistic removal before the server finished processing.

3. Bump client request limit from 500 to 1000 to match.

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* fix(client): prevent thread backfill after deletion

When deleting a thread with 1000+ total threads, the Amp API would
return a new thread from beyond the original window to replace the
deleted one, keeping the count unchanged despite the deletion.

Fix: snapshot the set of known thread IDs before the first delete.
While deletes are pending (2-minute grace period), only show threads
from the known set — filtering both the deleted thread and any
backfill. Genuinely new threads (created after the delete) are still
allowed through.

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* feat: lazy-load threads with auto-pagination and total count display

Start with 500 threads (1 API call). When user navigates to the last
page, automatically load the next 500. Shows total count in the
pagination bar: 'Showing 1-25 of 465 threads (1,000 total)'.

Server changes:
- getThreads uses offset-based pagination (replaces cursor-based)
- listAllThreads accepts limit param, fetches only what's needed
- hasMore based on whether full limit was returned
- totalCount reflects actual loaded thread count

Client changes:
- useThreads starts with 500, loadMore adds 500 more
- ThreadList auto-triggers loadMore when reaching last page
- PaginationBar shows total count when it differs from loaded count

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* fix(ui): show '465+' instead of misleading total count

Replace '(500 total)' / '(1,000 total)' with a simple '+' suffix
on the thread count when more are available. Shows 'Showing 1-25 of
465+ threads' until all threads are loaded, then drops the '+'.

Remove unused totalCount/serverTotalCount props.

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* feat(ui): show 'Loading more…' in pagination while fetching next batch

Wire loadingMore state through the context chain to PaginationBar.
When auto-load triggers on the last page, the page indicator shows
'Loading more…' instead of 'Page X of Y'.

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* fix: increase initial batch to 1000, fix lazy-load UX

- Bump BATCH_SIZE from 500→1000 to capture all top-level threads
  upfront (handoff stacking collapses ~530 children into existing
  entries, so 500 extra threads only added ~8 visible entries)
- Change auto-load from useEffect-based to click-based: load more
  only triggers when user clicks » or »» past the last page, not
  automatically on reaching it (prevents infinite loop)
- Keep » and »» enabled on last page when hasMore is true so user
  can explicitly request more data

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* fix: remove lazy-load pagination, keep simple 1000-thread upfront load

The lazy-load-on-paginate approach didn't work well because handoff
stacking absorbs most additional threads into existing entries — loading
500 more threads only added ~8 visible entries, making it seem broken.

Simplified to: load 1000 threads upfront (2 API calls), show '465+'
to indicate more raw threads exist as stacked children. Standard
pagination buttons with normal disabled behavior on last page.

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* fix(ui): remove misleading '+' from thread count

The '+' suffix implied more threads could be loaded, but handoff
stacking means all meaningful top-level threads are already visible
with the 1000-thread fetch. Loading more only adds ~8 entries since
extra threads are children absorbed into existing stacks.

Now shows a clean '465 threads' count.

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* refactor: load all threads, remove anti-backfill complexity

Load all threads from the Amp API (paginating internally at 500/call)
instead of capping at 1000 with anti-backfill workarounds. After the
bulk delete, thread count is ~496 which fits in a single API call.

Removes: knownIdsRef, deletedIdsRef, lastDeleteTimeRef, pruneDeleted,
loadMore, hasMore, totalCount, loadingMore — all the complexity added
to work around partial loading. The hook is now ~90 lines instead of
~165.

Delete now works simply: optimistic removal + server delete. The next
poll shows the real state with no backfill because ALL threads are
loaded.

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* fix(threads): replace broken API pagination with hybrid API+local loading

The Amp internal API's offset parameter is silently ignored — it always
returns the same threads regardless of offset value. The pagination loop
in listThreads() never actually paginated.

Changes:
- listThreads(): single API call with limit=500 (API max), no loop
- listAllThreads(): hybrid approach — API for up to 500 threads, then
  supplements with local thread files not in the API response
- Local file scan only triggers when API returns its max (500), meaning
  there are likely more threads on disk
- Remove unused limit/cursor params from getThreads() and route handler
- Client no longer sends limit=10000 query param

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* fix(threads): always scan local files, not just when API returns 500

The conditional scan missed older threads when API returned &lt;500
(e.g., after archiving/deleting). Local file scan is fast and
ensures threads beyond the API's 500 limit are always visible.

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

* fix(threads): delete local thread JSON file on delete to prevent zombie threads

cleanupThreadFiles() deleted artifacts and SQLite records but left the
thread JSON file in THREADS_DIR. After the hybrid loading change, the
local file scan would rediscover deleted threads on the next poll.

Co-authored-by: Amp &lt;amp@ampcode.com&gt;

---------

Co-authored-by: Amp &lt;amp@ampcode.com&gt;
diff --git a/server/lib/amp-api.ts b/server/lib/amp-api.ts
@@ -175,7 +175,19 @@ interface ListThreadsResult {
   threads: AmpThreadSummary[];
 }
 
-export async function listThreads(limit = 500): Promise<AmpThreadSummary[]> {
-  const result = await callAmpInternalAPI<ListThreadsResult>('listThreads', { limit });
+/** Maximum threads the Amp API returns in a single call. */
+export const AMP_API_MAX = 500;
+
+/**
+ * Fetch threads from the Amp internal API.
+ *
+ * The API's `offset` parameter is silently ignored — it always returns the
+ * same set of threads regardless of offset. So we make a single call with
+ * limit capped at 500 (the API maximum).
+ */
+export async function listThreads(): Promise<AmpThreadSummary[]> {
+  const result = await callAmpInternalAPI<ListThreadsResult>('listThreads', {
+    limit: AMP_API_MAX,
+  });
   return result.threads;
 }
diff --git a/server/lib/threadCrud.ts b/server/lib/threadCrud.ts
@@ -14,32 +14,13 @@ import {
   type ThreadFile,
 } from './threadTypes.js';
 
-interface GetThreadsOptions {
-  limit?: number;
-  cursor?: string | null;
-}
-
-export async function getThreads({
-  limit = 50,
-  cursor = null,
-}: GetThreadsOptions = {}): Promise<ThreadsResult> {
+export async function getThreads(): Promise<ThreadsResult> {
   const allThreads = await listAllThreads();
 
-  // Apply cursor-based pagination (same contract as before)
-  let startIndex = 0;
-  if (cursor) {
-    const cursorIndex = allThreads.findIndex((t) => t.id === cursor);
-    if (cursorIndex !== -1) startIndex = cursorIndex + 1;
-  }
-
-  const sliced = allThreads.slice(startIndex, startIndex + limit);
-  const hasMore = startIndex + limit < allThreads.length;
-  const lastThread = sliced[sliced.length - 1];
-
   return {
-    threads: sliced,
-    nextCursor: lastThread && hasMore ? lastThread.id : null,
-    hasMore,
+    threads: allThreads,
+    nextCursor: null,
+    hasMore: false,
   };
 }
 
@@ -121,6 +102,10 @@ export async function archiveThread(threadId: string): Promise<string> {
 }
 
 async function cleanupThreadFiles(threadId: string): Promise<void> {
+  // Delete the local thread JSON file so it doesn't resurface via local scan
+  const threadFile = join(THREADS_DIR, `${threadId}.json`);
+  await rm(threadFile, { force: true }).catch(() => {});
+
   // Delete artifacts directory
   const threadArtifactsDir = join(ARTIFACTS_DIR, threadId);
   await rm(threadArtifactsDir, { recursive: true, force: true }).catch(() => {});
@@ -139,9 +124,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 };
   }
 }
diff --git a/server/lib/threadProvider.ts b/server/lib/threadProvider.ts
@@ -47,22 +47,120 @@ function parseRepoFromUrl(url: string | undefined | null): string | null {
   return match?.[1] ?? url;
 }
 
-// ── List all threads via API ────────────────────────────────────────────
+// ── List all threads via API + local supplement ─────────────────────────
 
+/**
+ * Fetch all threads using a hybrid approach:
+ *   1. API call — returns up to 500 most-recent threads (the API's max)
+ *   2. Local file scan — picks up any threads on disk not already in the API
+ *      response (handles >500 threads or threads not yet synced to server)
+ *
+ * Returns threads sorted by lastUpdatedDate descending.
+ */
 export async function listAllThreads(): Promise<Thread[]> {
-  const summaries = await listThreads(500);
+  const summaries = await listThreads();
   const threads = summaries.map(toThread);
+  const apiIds = new Set(threads.map((t) => t.id));
+
+  // Always supplement with local thread files not in the API response.
+  // The API returns at most 500 most-recent threads, so older threads
+  // only appear via their local files on disk.
+  const localExtras = await getLocalOnlyThreads(apiIds);
+  threads.push(...localExtras);
 
-  // The listThreads API doesn't return relationship data.
-  // Enrich from two sources:
-  //   1. Local thread files (relationships[] array + handoff tool blocks)
-  //   2. Shared thread ID prefix heuristic (handoff batches share first 4 UUID segments)
+  // Enrich handoff relationships from local files + batch heuristic
   await enrichRelationships(threads);
   enrichBatchSiblings(threads);
 
+  // Sort by last updated descending (API threads are already sorted, but
+  // local extras may interleave)
+  threads.sort(
+    (a, b) =>
+      new Date(b.lastUpdatedDate || 0).getTime() - new Date(a.lastUpdatedDate || 0).getTime(),
+  );
+
   return threads;
 }
 
+/**
+ * Scan local thread files and return Thread objects for IDs not in `knownIds`.
+ * Reads only the minimal fields needed (title, timestamps, env) — does NOT
+ * parse full message content.
+ */
+async function getLocalOnlyThreads(knownIds: Set<string>): Promise<Thread[]> {
+  let files: string[];
+  try {
+    files = await readdir(THREADS_DIR);
+  } catch {
+    return [];
+  }
+
+  const extras: Thread[] = [];
+  const jsonFiles = files.filter((f) => f.startsWith('T-') && f.endsWith('.json'));
+
+  await Promise.all(
+    jsonFiles.map(async (file) => {
+      const threadId = file.replace('.json', '');
+      if (knownIds.has(threadId)) return;
+
+      try {
+        const content = await readFile(join(THREADS_DIR, file), 'utf-8');
+        const data = JSON.parse(content) as ThreadFile;
+        extras.push(localFileToThread(threadId, data));
+      } catch {
+        // Skip unreadable files
+      }
+    }),
+  );
+
+  return extras;
+}
+
+/**
+ * Convert a local ThreadFile into the shared Thread type.
+ * Mirrors toThread() but works from the on-disk JSON shape.
+ */
+function localFileToThread(id: string, data: ThreadFile): Thread {
+  const tree = data.env?.initial?.trees?.[0];
+  const repoUrl = tree?.repository?.url;
+
+  let handoffParentId: string | null = null;
+  const handoffChildIds: string[] = [];
+  for (const rel of data.relationships || []) {
+    if (isHandoffRelationship(rel)) {
+      if (rel.role === 'child') {
+        handoffParentId = rel.threadID;
+      } else {
+        handoffChildIds.push(rel.threadID);
+      }
+    }
+  }
+
+  const createdMs = data.created || 0;
+  const lastDate = new Date(createdMs);
+
+  return {
+    id,
+    title: data.title || id,
+    lastUpdated: formatRelativeTime(lastDate),
+    lastUpdatedDate: lastDate.toISOString(),
+    visibility: normalizeVisibility(data.visibility ?? data.meta?.visibility),
+    messages: (data.messages || []).length,
+    workspace: tree?.displayName || null,
+    workspacePath: parseFileUri(tree?.uri) || null,
+    repo: parseRepoFromUrl(repoUrl),
+    handoffParentId,
+    handoffChildIds: [...new Set(handoffChildIds)],
+    agentMode: data.agentMode,
+    archived: false,
+    model: undefined,
+    cost: undefined,
+    contextPercent: undefined,
+    maxContextTokens: undefined,
+    touchedFiles: undefined,
+  };
+}
+
 /**
  * Scan local thread files for handoff relationships and merge them into
  * the thread list. Checks two sources:
diff --git a/server/routes/threads.ts b/server/routes/threads.ts
@@ -34,9 +34,7 @@ export async function handleThreadRoutes(
 
   if (pathname === '/api/threads') {
     try {
-      const limit = parseInt(url.searchParams.get('limit') || '50', 10);
-      const cursor = url.searchParams.get('cursor') || null;
-      const result = await getThreads({ limit, cursor });
+      const result = await getThreads();
 
       // Trigger background actual cost fetching for visible threads
       enqueueCostFetch(result.threads.map((t: { id: string }) => t.id));
diff --git a/src/hooks/useThreadActions.ts b/src/hooks/useThreadActions.ts
@@ -145,8 +145,8 @@ export function useThreadActions({
       } catch (err) {
         console.error('Bulk archive error:', err);
         showError('Some threads failed to archive');
+        refetch();
       }
-      refetch();
     },
     [refetch, removeThread, showError],
   );
@@ -171,12 +171,13 @@ export function useThreadActions({
         if (failures.length > 0) {
           console.error(`${failures.length} delete(s) failed`);
           showError(`${failures.length} thread(s) failed to delete`);
+          refetch();
         }
       } catch (err) {
         console.error('Bulk delete error:', err);
         showError('Some threads failed to delete');
+        refetch();
       }
-      refetch();
     },
     [refetch, removeThread, showError],
   );
diff --git a/src/hooks/useThreads.ts b/src/hooks/useThreads.ts
@@ -8,47 +8,31 @@ const AUTO_REFRESH_INTERVAL_MS = 30000;
 export function useThreads() {
   const [threads, setThreads] = useState<Thread[]>([]);
   const [loading, setLoading] = useState(true);
-  const [loadingMore, setLoadingMore] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const [hasMore, setHasMore] = useState(false);
-  const cursorRef = useRef<string | null>(null);
   const autoRefreshRef = useRef<number | null>(null);
 
-  const fetchThreads = useCallback(async (append = false) => {
-    if (append) {
-      setLoadingMore(true);
-    } else {
-      setLoading(true);
-    }
+  const fetchThreads = useCallback(async () => {
+    setLoading(true);
     setError(null);
 
     try {
-      const cursor = append ? cursorRef.current : null;
-      const data = await apiGet<ThreadsResult>(
-        `/api/threads?limit=50${cursor ? `&cursor=${cursor}` : ''}`,
-      );
+      const data = await apiGet<ThreadsResult>('/api/threads');
 
-      if (append) {
-        setThreads((prev) => [...prev, ...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 !== 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;
+      // 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
+          );
         });
-      }
-      cursorRef.current = data.nextCursor;
-      setHasMore(data.hasMore);
+        return changed ? data.threads : prev;
+      });
     } catch (err) {
       if (err instanceof ApiError) {
         console.error(`[useThreads] API error ${err.status}: ${err.message}`);
@@ -59,16 +43,9 @@ export function useThreads() {
       }
     } finally {
       setLoading(false);
-      setLoadingMore(false);
     }
   }, []);
 
-  const loadMore = useCallback(() => {
-    if (hasMore && !loadingMore) {
-      void fetchThreads(true);
-    }
-  }, [hasMore, loadingMore, fetchThreads]);
-
   const removeThread = useCallback((threadId: string) => {
     setThreads((prev) => prev.filter((t) => t.id !== threadId));
   }, []);
@@ -79,7 +56,7 @@ export function useThreads() {
     const startPolling = () => {
       if (autoRefreshRef.current !== null) return;
       autoRefreshRef.current = window.setInterval(() => {
-        void fetchThreads(false);
+        void fetchThreads();
       }, AUTO_REFRESH_INTERVAL_MS);
     };
 
@@ -94,7 +71,7 @@ export function useThreads() {
       if (document.hidden) {
         stopPolling();
       } else {
-        void fetchThreads(false);
+        void fetchThreads();
         startPolling();
       }
     };
@@ -111,11 +88,8 @@ export function useThreads() {
   return {
     threads,
     loading,
-    loadingMore,
     error,
-    hasMore,
-    refetch: () => fetchThreads(false),
-    loadMore,
+    refetch: fetchThreads,
     removeThread,
   };
 }
