refactor(server): migrate thread storage from filesystem to Amp API

Amp stopped writing thread JSON files to disk (~March 31 2026). New
threads exist only on the Amp server, causing our app to see 25 of 500+
threads.

Changes:
- Add threadProvider.ts with listAllThreads() (uses listThreads internal
  API) and readThreadFile() (local file → amp threads export fallback)
- Rewrite getThreads() to use API instead of readdir+readFile scan
- Migrate all 12 single-file readers to use readThreadFile()
- Fix deleteThread auth bug: switch to 'amp threads delete' CLI
- Fix search: use 'amp threads search --json' CLI
- Remove 'free' agent mode (removed by Amp)
- Handle visibility casing change (Private→private)
- Guard truncate/undo for server-only threads with clear error
- Update workspaces to use API tree data directly
- Skip file watcher for server-only threads

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

Author: jom-sq

server/lib/amp-api.ts

@@ -130,3 +130,52 @@ export async function callAmpInternalAPI<T = unknown>(
   // eslint-disable-next-line @typescript-eslint/only-throw-error -- TODO: wrap lastError in a proper Error
   throw lastError;
 }
+
+// ── listThreads internal API ────────────────────────────────────────────
+
+export interface AmpThreadTree {
+  uri: string;
+  displayName: string;
+  repository?: { url: string; ref?: string; sha?: string; type?: string };
+}
+
+export interface AmpThreadSummary {
+  id: string;
+  v: number;
+  title: string;
+  created: number;
+  userLastInteractedAt: number;
+  messageCount: number;
+  agentMode: string;
+  archived: boolean;
+  creatorUserID: string;
+  usesDtw: boolean;
+  env: {
+    initial: {
+      trees: AmpThreadTree[];
+    };
+  };
+  relationships: Array<{
+    type: string;
+    role: 'parent' | 'child';
+    threadID: string;
+    comment?: string;
+  }>;
+  summaryStats?: {
+    diffStats?: { added: number; changed: number; deleted: number };
+    messageCount: number;
+  };
+  meta: {
+    visibility: string;
+    sharedGroupIDs: string[];
+  };
+}
+
+interface ListThreadsResult {
+  threads: AmpThreadSummary[];
+}
+
+export async function listThreads(limit = 500): Promise<AmpThreadSummary[]> {
+  const result = await callAmpInternalAPI<ListThreadsResult>('listThreads', { limit });
+  return result.threads;
+}

server/lib/contextAnalyze.ts

@@ -1,6 +1,5 @@
-import { readFile } from 'fs/promises';
-import { join } from 'path';
-import { THREADS_DIR, type ThreadFile, isToolUseContent } from './threadTypes.js';
+import { isToolUseContent } from './threadTypes.js';
+import { readThreadFile } from './threadProvider.js';
 import {
   calculateCost,
   isHiddenCostTool,
@@ -53,9 +52,7 @@ export interface ContextAnalysis {
 }
 
 export async function analyzeContext(threadId: string): Promise<ContextAnalysis> {
-  const threadPath = join(THREADS_DIR, `${threadId}.json`);
-  const content = await readFile(threadPath, 'utf-8');
-  const data = JSON.parse(content) as ThreadFile;
+  const data = await readThreadFile(threadId);
 
   const tags = data.env?.initial?.tags || [];
   const modelTag = tags.find((t: string) => t.startsWith('model:'));

server/lib/git-activity.ts

@@ -1,9 +1,9 @@
 import { spawn, ChildProcess } from 'child_process';
 import { readFile, writeFile, mkdir, stat } from 'fs/promises';
-import type { Stats } from 'fs';
 import { join, dirname, isAbsolute, relative, basename } from 'path';
 import { AMP_HOME } from './constants.js';
 import { THREADS_DIR } from './threadTypes.js';
+import { readThreadFile } from './threadProvider.js';
 import type {
   ThreadGitActivity,
   WorkspaceGitActivity,
@@ -578,12 +578,18 @@ export async function getThreadGitActivity(
   threadId: string,
   forceRefresh = false,
 ): Promise<ThreadGitActivity> {
-  const threadPath = join(THREADS_DIR, `${threadId}.json`);
-
   try {
-    const content = await readFile(threadPath, 'utf-8');
-    const data = JSON.parse(content) as ThreadData;
-    const threadStat: Stats = await stat(threadPath);
+    const data = (await readThreadFile(threadId)) as unknown as ThreadData;
+
+    // stat the local file for cache invalidation — may not exist for server-only threads
+    let threadMtimeMs = 0;
+    try {
+      const threadPath = join(THREADS_DIR, `${threadId}.json`);
+      const threadStat = await stat(threadPath);
+      threadMtimeMs = threadStat.mtimeMs;
+    } catch {
+      // No local file — skip cache check (always recompute)
+    }
 
     const trees = data.env?.initial?.trees || [];
     if (trees.length === 0) {
@@ -631,7 +637,8 @@ export async function getThreadGitActivity(
 
       const cacheValid =
         cachedWorkspace &&
-        cache?.threadMtimeMs === threadStat.mtimeMs &&
+        cache?.threadMtimeMs === threadMtimeMs &&
+        threadMtimeMs > 0 &&
         cachedWorkspace.gitHeadSha === headSha &&
         !forceRefresh;
 
@@ -698,7 +705,7 @@ export async function getThreadGitActivity(
 
     const result: CacheData = {
       threadId,
-      threadMtimeMs: threadStat.mtimeMs,
+      threadMtimeMs,
       computedAtMs: Date.now(),
       workspaces,
     };

server/lib/git.ts

@@ -2,8 +2,8 @@ import { spawn, ChildProcess } from 'child_process';
 import { readFile, stat, unlink } from 'fs/promises';
 import { join, resolve, isAbsolute } from 'path';
 import type { GitStatus, GitFileStatus, FileDiff } from '../../shared/types.js';
-import { THREADS_DIR } from './threadTypes.js';
 import { parseFileUri } from './utils.js';
+import { readThreadFile } from './threadProvider.js';
 
 /**
  * Validates and sanitizes a workspace path to prevent path traversal attacks.
@@ -189,11 +189,8 @@ interface GitStatusError {
 }
 
 export async function getWorkspaceGitStatus(threadId: string): Promise<GitStatus | GitStatusError> {
-  const threadPath = join(THREADS_DIR, `${threadId}.json`);
-
   try {
-    const content = await readFile(threadPath, 'utf-8');
-    const data = JSON.parse(content) as ThreadData;
+    const data = (await readThreadFile(threadId)) as unknown as ThreadData;
 
     const trees = data.env?.initial?.trees || [];
     if (trees.length === 0) {

server/lib/mentionResolver.ts

@@ -1,6 +1,7 @@
 import { readFile } from 'fs/promises';
-import { join, resolve } from 'path';
-import { THREADS_DIR, isTextContent, type ThreadFile } from './threadTypes.js';
+import { resolve } from 'path';
+import { isTextContent } from './threadTypes.js';
+import { readThreadFile } from './threadProvider.js';
 
 const MAX_FILE_SIZE = 100 * 1024; // 100KB cap for injected file contents
 const MAX_FILE_LINES = 2000; // Max lines to inject
@@ -79,9 +80,7 @@ async function readFileContents(
 
 async function getThreadTitle(threadId: string): Promise<string | null> {
   try {
-    const filePath = join(THREADS_DIR, `${threadId}.json`);
-    const content = await readFile(filePath, 'utf-8');
-    const data = JSON.parse(content) as ThreadFile;
+    const data = await readThreadFile(threadId);
     if (data.title) return data.title;
 
     const firstUser = data.messages?.find((m) => m.role === 'user');

server/lib/promptHistory.ts

@@ -1,12 +1,11 @@
-import { readFile, readdir, stat } from 'fs/promises';
-import { join } from 'path';
-import { THREADS_DIR, isTextContent, type ThreadFile } from './threadTypes.js';
+import { isTextContent } from './threadTypes.js';
 import {
   recordPrompt,
   searchPromptHistory,
   getPromptHistoryCount,
   type PromptHistoryRow,
 } from './database.js';
+import { listAllThreads, readThreadFile } from './threadProvider.js';
 
 let backfillPromise: Promise<void> | null = null;
 
@@ -20,38 +19,27 @@ async function backfillPromptHistory(): Promise<void> {
     // Skip if already backfilled (data persists across restarts)
     if (getPromptHistoryCount() > 0) return;
 
-    const files = await readdir(THREADS_DIR);
-    const threadFiles = files.filter((f) => f.startsWith('T-') && f.endsWith('.json'));
+    const threads = await listAllThreads();
 
-    // Stat all files and sort oldest-first so duplicate prompts keep the most recent timestamp
-    const fileStats = (
-      await Promise.all(
-        threadFiles.map(async (file) => {
-          try {
-            const fileStat = await stat(join(THREADS_DIR, file));
-            return { file, mtimeMs: fileStat.mtimeMs };
-          } catch {
-            return null;
-          }
-        }),
-      )
-    )
-      .filter((s): s is { file: string; mtimeMs: number } => s !== null)
-      .sort((a, b) => a.mtimeMs - b.mtimeMs);
+    // Sort oldest-first so duplicate prompts keep the most recent timestamp
+    const sorted = [...threads].sort((a, b) => {
+      const aDate = a.lastUpdatedDate ? new Date(a.lastUpdatedDate).getTime() : 0;
+      const bDate = b.lastUpdatedDate ? new Date(b.lastUpdatedDate).getTime() : 0;
+      return aDate - bDate;
+    });
 
     // Process in parallel batches to avoid overwhelming the filesystem
     const BATCH_SIZE = 20;
-    for (let i = 0; i < fileStats.length; i += BATCH_SIZE) {
-      const batch = fileStats.slice(i, i + BATCH_SIZE);
+    for (let i = 0; i < sorted.length; i += BATCH_SIZE) {
+      const batch = sorted.slice(i, i + BATCH_SIZE);
       await Promise.all(
-        batch.map(async ({ file, mtimeMs }) => {
+        batch.map(async (thread) => {
           try {
-            const filePath = join(THREADS_DIR, file);
-            const fileMtime = Math.floor(mtimeMs / 1000);
-            const content = await readFile(filePath, 'utf-8');
-            const data = JSON.parse(content) as ThreadFile;
-            const threadId = file.replace('.json', '');
+            const data = await readThreadFile(thread.id);
             const messages = data.messages || [];
+            const fileMtime = thread.lastUpdatedDate
+              ? Math.floor(new Date(thread.lastUpdatedDate).getTime() / 1000)
+              : Math.floor(Date.now() / 1000);
 
             for (const msg of messages) {
               if (msg.role !== 'user') continue;
@@ -65,19 +53,19 @@ async function backfillPromptHistory(): Promise<void> {
               }
 
               if (text.trim()) {
-                // Use message sentAt if available, otherwise fall back to file mtime
+                // Use message sentAt if available, otherwise fall back to thread lastUpdated
                 const createdAt = msg.meta?.sentAt ? Math.floor(msg.meta.sentAt / 1000) : fileMtime;
-                recordPrompt(text, threadId, createdAt);
+                recordPrompt(text, thread.id, createdAt);
               }
             }
           } catch (err) {
-            console.warn(`[prompt-history] Failed to parse ${file}:`, err);
+            console.warn(`[prompt-history] Failed to parse ${thread.id}:`, err);
           }
         }),
       );
     }
 
-    console.warn(`📋 Prompt history backfill complete (scanned ${threadFiles.length} threads)`);
+    console.warn(`📋 Prompt history backfill complete (scanned ${sorted.length} threads)`);
   } catch (err) {
     console.error('[prompt-history] Backfill failed:', err);
   }
@@ -132,25 +120,15 @@ export function addPromptToHistory(text: string, threadId: string): void {
  */
 export async function getRecentThreadIds(limit = 100): Promise<string[]> {
   try {
-    const files = await readdir(THREADS_DIR);
-    const threadFiles = files.filter((f) => f.startsWith('T-') && f.endsWith('.json'));
-
-    const stats = await Promise.all(
-      threadFiles.map(async (file) => {
-        try {
-          const fileStat = await stat(join(THREADS_DIR, file));
-          return { file, mtime: fileStat.mtime.getTime() };
-        } catch {
-          return null;
-        }
-      }),
-    );
-
-    return stats
-      .filter((s): s is { file: string; mtime: number } => s !== null)
-      .sort((a, b) => b.mtime - a.mtime)
+    const threads = await listAllThreads();
+    return threads
+      .sort((a, b) => {
+        const aDate = a.lastUpdatedDate ? new Date(a.lastUpdatedDate).getTime() : 0;
+        const bDate = b.lastUpdatedDate ? new Date(b.lastUpdatedDate).getTime() : 0;
+        return bDate - aDate;
+      })
       .slice(0, limit)
-      .map((s) => s.file.replace('.json', ''));
+      .map((t) => t.id);
   } catch {
     return [];
   }