From ac5d24e8235d1956007b0e86b69d38a652812c09 Mon Sep 17 00:00:00 2001
From: Ayush7614 <ayushknj3@gmail.com>
Date: Fri, 11 Sep 2026 14:42:38 +0530
Subject: [PATCH 1/8] perf(posts): memoised replies, paginated comments,
 persistent drafts

TokenComments filtered the whole list per top-level post (O(n^2) per
render) and rendered every comment at once with a silent slice composer.
Build the reply map once with groupReplies, paginate the top level at 20
with a Show more button and live status, persist the draft per token so a
failed signature or reload never loses a typed comment, and announce the
character count and errors to assistive tech.
---
 app/src/components/launchpad/Posts.tsx     | 55 ++++++++++++++----
 app/src/lib/launchpad/post-threads.test.ts | 38 +++++++++++++
 app/src/lib/launchpad/post-threads.ts      | 65 ++++++++++++++++++++++
 3 files changed, 148 insertions(+), 10 deletions(-)
 create mode 100644 app/src/lib/launchpad/post-threads.test.ts
 create mode 100644 app/src/lib/launchpad/post-threads.ts

diff --git a/app/src/components/launchpad/Posts.tsx b/app/src/components/launchpad/Posts.tsx
index 69f8d90a..d6e68cca 100644
--- a/app/src/components/launchpad/Posts.tsx
+++ b/app/src/components/launchpad/Posts.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 import Link from "next/link";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useAccount, useConfig } from "wagmi";
 import { getWalletClient } from "wagmi/actions";
 import WalletAvatar from "@/components/WalletAvatar";
@@ -10,6 +10,7 @@ import { useLive } from "./LiveProvider";
 import { toast } from "./TxToasts";
 import { btn } from "@/components/ui";
 import { buildModMessage, buildPostMessage, buildReportMessage, POST_MAX, REPORT_REASONS, validateBody, type ReportReason } from "@/lib/launchpad/posts";
+import { COMMENTS_PAGE, clearDraft, groupReplies, loadDraft, saveDraft, visibleTopIds } from "@/lib/launchpad/post-threads";
 import type { PostRow } from "@/lib/launchpad/postsServer";
 import { ago, nowMs } from "@/lib/launchpad/time";
 import { CHAINS, CHAIN_SHORT, shortAddr, type ChainKey } from "@/lib/chainPublic";
@@ -51,6 +52,16 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
   const [busy, setBusy] = useState(false);
   const [err, setErr] = useState<string | null>(null);
   const [now, setNow] = useState(0);
+  const [shownCount, setShownCount] = useState(COMMENTS_PAGE);
+  // Draft restores async after hydration so server and client render the same empty composer first.
+  useEffect(() => {
+    const t = setTimeout(() => {
+      const d = loadDraft(chain, token);
+      if (d) setBody(d.slice(0, POST_MAX));
+      setShownCount(COMMENTS_PAGE);
+    }, 0);
+    return () => clearTimeout(t);
+  }, [chain, token]);
   const seenPosts = useRef<string>("");
   const isCreator = Boolean(address && address.toLowerCase() === launcher.toLowerCase());
 
@@ -104,6 +115,7 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
       if (!res.ok || !d.post) throw new Error(d.error ?? "post rejected");
       setPosts((cur) => [d.post!, ...cur]);
       setBody("");
+      clearDraft(chain, token);
       setReplyTo(null);
     } catch (e) {
       setErr(friendlyError(e));
@@ -145,8 +157,9 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
     }
   }
 
-  const top = posts.filter((p) => p.parent_id === null);
-  const replies = (id: number) => posts.filter((p) => p.parent_id === id).slice().reverse();
+  const { top, repliesById } = useMemo(() => groupReplies(posts), [posts]);
+  const visibleTop = useMemo(() => visibleTopIds(top, shownCount), [top, shownCount]);
+  const remaining = top.length - visibleTop.length;
 
   return (
     <section className={embedded ? "overflow-hidden bg-paper" : "rounded-2xl bg-card border border-line overflow-hidden"} id="comments">
@@ -182,29 +195,37 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
             ) : null}
             <textarea
               value={body}
-              onChange={(e) => setBody(e.target.value.slice(0, POST_MAX))}
+              onChange={(e) => {
+                const next = e.target.value.slice(0, POST_MAX);
+                setBody(next);
+                saveDraft(chain, token, next);
+              }}
               placeholder={`Say something about ${symbol}…`}
+              aria-label={`Comment about ${symbol}`}
+              aria-describedby={`comment-count-${chain}`}
               className="w-full rounded-xl bg-card border border-line-strong focus:border-brand focus:ring-4 focus:ring-brand/10 outline-none px-3 py-2 text-sm text-ink placeholder:text-faint min-h-16 resize-y"
             />
             <div className="flex items-center justify-between gap-3">
-              <span className="text-[11px] text-muted font-mono tnum">{POST_MAX - body.length}</span>
+              <span id={`comment-count-${chain}`} aria-live="polite" className="text-[11px] text-muted font-mono tnum">{POST_MAX - body.length}</span>
               <button type="button" onClick={() => void submit()} disabled={busy || !body.trim()} className={btn.primarySm}>
                 {busy ? "Sign in wallet…" : replyTo !== null ? "Reply" : "Post"}
               </button>
             </div>
-            {err ? <p className="text-xs text-down-ink">{err}</p> : null}
+            {err ? <p className="text-xs text-down-ink" role="alert">{err}</p> : null}
           </div>
         )}
       </div>
 
       <ul className="divide-y divide-line">
         {top.length === 0 ? <li className="px-4 py-8 text-center text-sm text-muted">No comments yet.</li> : null}
-        {top.map((p) => (
+        {visibleTop.map((p) => {
+          const thread = repliesById.get(p.id) ?? [];
+          return (
           <li key={p.id} className="px-4 py-3">
             <PostItem p={p} now={now} canReply={isConnected && !muted} onReply={() => setReplyTo(p.id)} onReport={address && p.wallet !== address.toLowerCase() ? (r) => void report(p, r) : undefined} />
-            {replies(p.id).length ? (
+            {thread.length ? (
               <ul className="mt-2 ml-6 pl-3 border-l border-line space-y-2">
-                {replies(p.id).map((r) => (
+                {thread.map((r) => (
                   <li key={r.id}>
                     <PostItem p={r} now={now} canReply={false} onReport={address && r.wallet !== address.toLowerCase() ? (x) => void report(r, x) : undefined} />
                   </li>
@@ -212,8 +233,22 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
               </ul>
             ) : null}
           </li>
-        ))}
+          );
+        })}
       </ul>
+      {remaining > 0 ? (
+        <div className="border-t border-line px-4 py-3 text-center">
+          <button
+            type="button"
+            onClick={() => setShownCount((n) => n + COMMENTS_PAGE)}
+            aria-label={`Show more comments, ${remaining} remaining`}
+            className="min-h-10 rounded-xl border border-line-strong px-4 text-sm font-medium text-ink hover:bg-card"
+          >
+            Show more comments ({visibleTop.length} of {top.length})
+          </button>
+          <p className="mt-1 text-[11px] text-muted" role="status">Showing {visibleTop.length} of {top.length} comments</p>
+        </div>
+      ) : null}
     </section>
   );
 }
diff --git a/app/src/lib/launchpad/post-threads.test.ts b/app/src/lib/launchpad/post-threads.test.ts
new file mode 100644
index 00000000..bb7a0a96
--- /dev/null
+++ b/app/src/lib/launchpad/post-threads.test.ts
@@ -0,0 +1,38 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { COMMENTS_PAGE, clearDraft, draftKey, groupReplies, loadDraft, saveDraft, visibleTopIds } from "./post-threads.ts";
+import type { PostRow } from "./postsServer.ts";
+
+const post = (id: number, parent_id: number | null): PostRow => ({ id, chain: "base", token: "0xtoken", wallet: "0xwallet", parent_id, body: `body ${id}`, tag: null, created_at: "2026-01-01T00:00:00.000Z", reports: 0, hidden: false });
+
+test("groupReplies splits top-level from one-level replies, newest reply last", () => {
+  const posts = [post(3, null), post(2, 3), post(1, 3), post(4, null)];
+  const { top, repliesById } = groupReplies(posts);
+  assert.deepEqual(top.map((p) => p.id), [3, 4]);
+  assert.deepEqual(repliesById.get(3)!.map((p) => p.id), [1, 2], "server order (newest first) reverses to oldest-first under the comment");
+  assert.equal(repliesById.get(4), undefined);
+});
+
+test("groupReplies on empty / replies-only input", () => {
+  assert.deepEqual(groupReplies([]).top, []);
+  const { top, repliesById } = groupReplies([post(9, 7)]);
+  assert.deepEqual(top, []);
+  assert.deepEqual(repliesById.get(7)!.map((p) => p.id), [9]);
+});
+
+test("visibleTopIds paginates the top level", () => {
+  const top = [post(1, null), post(2, null), post(3, null)];
+  assert.deepEqual(visibleTopIds(top, 2).map((p) => p.id), [1, 2]);
+  assert.deepEqual(visibleTopIds(top, 99).map((p) => p.id), [1, 2, 3]);
+  assert.deepEqual(visibleTopIds(top, 0), []);
+  assert.equal(COMMENTS_PAGE, 20);
+});
+
+test("draft key is per token and lowercase; node loads empty and saves are no-ops", () => {
+  assert.equal(draftKey("base", "0xABC"), "ol:comment-draft:base:0xabc");
+  assert.notEqual(draftKey("base", "0xabc"), draftKey("robinhood", "0xabc"));
+  assert.equal(loadDraft("base", "0xabc"), "");
+  saveDraft("base", "0xabc", "hello");
+  clearDraft("base", "0xabc");
+  assert.equal(loadDraft("base", "0xabc"), "", "no localStorage in node: always empty, never throws");
+});
diff --git a/app/src/lib/launchpad/post-threads.ts b/app/src/lib/launchpad/post-threads.ts
new file mode 100644
index 00000000..8a2cf268
--- /dev/null
+++ b/app/src/lib/launchpad/post-threads.ts
@@ -0,0 +1,65 @@
+import type { PostRow } from "./postsServer";
+
+/**
+ * Token-page comment threading + composer helpers (pure; unit-tested).
+ *
+ * TokenComments rendered every reply list with `posts.filter(p => p.parent_id
+ * === id)` per top-level post: O(n²) per render on a viral token. These
+ * helpers build the reply map once (O(n)) and own client pagination + draft
+ * persistence so the component stays thin.
+ */
+
+/** How many top-level comments render before "Show more". */
+export const COMMENTS_PAGE = 20;
+
+export function groupReplies(posts: PostRow[]): { top: PostRow[]; repliesById: Map<number, PostRow[]> } {
+  const top: PostRow[] = [];
+  const repliesById = new Map<number, PostRow[]>();
+  for (const p of posts) {
+    if (p.parent_id === null) top.push(p);
+    else {
+      const list = repliesById.get(p.parent_id);
+      if (list) list.push(p);
+      else repliesById.set(p.parent_id, [p]);
+    }
+  }
+  // Newest reply last under each comment (server sends newest first).
+  for (const list of repliesById.values()) list.reverse();
+  return { top, repliesById };
+}
+
+export function visibleTopIds(top: PostRow[], shownCount: number): PostRow[] {
+  return top.slice(0, Math.max(0, shownCount));
+}
+
+export function draftKey(chain: string, token: string): string {
+  return `ol:comment-draft:${chain}:${token.toLowerCase()}`;
+}
+
+export function loadDraft(chain: string, token: string): string {
+  try {
+    if (typeof localStorage === "undefined") return "";
+    return localStorage.getItem(draftKey(chain, token)) ?? "";
+  } catch {
+    return "";
+  }
+}
+
+export function saveDraft(chain: string, token: string, body: string): void {
+  try {
+    if (typeof localStorage === "undefined") return;
+    if (!body) localStorage.removeItem(draftKey(chain, token));
+    else localStorage.setItem(draftKey(chain, token), body.slice(0, 2000));
+  } catch {
+    /* storage blocked: the in-memory textarea state is what survives */
+  }
+}
+
+export function clearDraft(chain: string, token: string): void {
+  try {
+    if (typeof localStorage === "undefined") return;
+    localStorage.removeItem(draftKey(chain, token));
+  } catch {
+    /* ignore */
+  }
+}

From bb8b1f8846bcb376d289071a101fc456316975bb Mon Sep 17 00:00:00 2001
From: Ayush7614 <ayushknj3@gmail.com>
Date: Fri, 11 Sep 2026 15:00:20 +0530
Subject: [PATCH 2/8] fix(posts): always reset composer body on token change
 (CodeRabbit, PR #31)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The draft-restore effect only assigned when a draft existed, so text
typed for one token stayed in state — and was submittable — after
switching to a token without a draft. Always assign the loaded value,
even when empty.
---
 app/src/components/launchpad/Posts.tsx | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/app/src/components/launchpad/Posts.tsx b/app/src/components/launchpad/Posts.tsx
index d6e68cca..122190d0 100644
--- a/app/src/components/launchpad/Posts.tsx
+++ b/app/src/components/launchpad/Posts.tsx
@@ -54,10 +54,11 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
   const [now, setNow] = useState(0);
   const [shownCount, setShownCount] = useState(COMMENTS_PAGE);
   // Draft restores async after hydration so server and client render the same empty composer first.
+  // The loaded value is always assigned (even when empty) so text typed for one
+  // token can never leak into — and be submitted from — another token's composer.
   useEffect(() => {
     const t = setTimeout(() => {
-      const d = loadDraft(chain, token);
-      if (d) setBody(d.slice(0, POST_MAX));
+      setBody(loadDraft(chain, token).slice(0, POST_MAX));
       setShownCount(COMMENTS_PAGE);
     }, 0);
     return () => clearTimeout(t);

From 753003c95146098874b61d714edb20d2a5c562f2 Mon Sep 17 00:00:00 2001
From: Ayush7614 <ayushknj3@gmail.com>
Date: Sat, 12 Sep 2026 17:59:25 +0530
Subject: [PATCH 3/8] fix(posts): persist and restore reply target with draft
 (PR #31)

- drafts store {body, parentId} JSON, legacy plain-text still reads
- composer restores both, persists on type/reply/cancel
- missing/hidden parent derives to top-level with explicit notice, no effect loop
- tests for top-level vs reply restore and legacy/bad parent handling
---
 app/src/components/launchpad/Posts.tsx     | 37 ++++++++++-----
 app/src/lib/launchpad/post-threads.test.ts | 52 +++++++++++++++++++++-
 app/src/lib/launchpad/post-threads.ts      | 37 ++++++++++++---
 3 files changed, 108 insertions(+), 18 deletions(-)

diff --git a/app/src/components/launchpad/Posts.tsx b/app/src/components/launchpad/Posts.tsx
index 122190d0..c22544e8 100644
--- a/app/src/components/launchpad/Posts.tsx
+++ b/app/src/components/launchpad/Posts.tsx
@@ -10,7 +10,7 @@ import { useLive } from "./LiveProvider";
 import { toast } from "./TxToasts";
 import { btn } from "@/components/ui";
 import { buildModMessage, buildPostMessage, buildReportMessage, POST_MAX, REPORT_REASONS, validateBody, type ReportReason } from "@/lib/launchpad/posts";
-import { COMMENTS_PAGE, clearDraft, groupReplies, loadDraft, saveDraft, visibleTopIds } from "@/lib/launchpad/post-threads";
+import { COMMENTS_PAGE, clearDraft, groupReplies, loadCommentDraft, saveDraft, visibleTopIds } from "@/lib/launchpad/post-threads";
 import type { PostRow } from "@/lib/launchpad/postsServer";
 import { ago, nowMs } from "@/lib/launchpad/time";
 import { CHAINS, CHAIN_SHORT, shortAddr, type ChainKey } from "@/lib/chainPublic";
@@ -56,9 +56,13 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
   // Draft restores async after hydration so server and client render the same empty composer first.
   // The loaded value is always assigned (even when empty) so text typed for one
   // token can never leak into — and be submitted from — another token's composer.
+  // The reply destination restores with the body: otherwise a reload turns a
+  // reply draft into a top-level post (parentId: null).
   useEffect(() => {
     const t = setTimeout(() => {
-      setBody(loadDraft(chain, token).slice(0, POST_MAX));
+      const d = loadCommentDraft(chain, token);
+      setBody(d.body.slice(0, POST_MAX));
+      setReplyTo(d.parentId);
       setShownCount(COMMENTS_PAGE);
     }, 0);
     return () => clearTimeout(t);
@@ -97,6 +101,13 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
     [subscribe, chain, token, load],
   );
 
+  // A restored reply target may be gone (hidden, deleted, or another token's
+  // id). Derive the effective target during render so the draft posts
+  // top-level instead of 404ing — no set-state-in-effect, no flash of a stale
+  // "Replying to #". Before posts load we assume the target exists.
+  const replyMissing = replyTo !== null && posts.length > 0 && !posts.some((p) => p.id === replyTo);
+  const effectiveReplyTo = replyMissing ? null : replyTo;
+
   async function submit() {
     if (!address) return;
     const v = validateBody(body);
@@ -104,14 +115,16 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
       setErr(v.error);
       return;
     }
+    // Re-derive here: posts may have changed since the last render.
+    const target = replyTo !== null && posts.length > 0 && !posts.some((p) => p.id === replyTo) ? null : replyTo;
     setBusy(true);
     setErr(null);
     try {
       const n = nonce();
       const ts = nowMs();
-      const message = buildPostMessage({ chain, token, wallet: address, nonce: n, ts, parentId: replyTo, body: v.body });
+      const message = buildPostMessage({ chain, token, wallet: address, nonce: n, ts, parentId: target, body: v.body });
       const { signature } = await signed(config, chain, message);
-      const res = await fetch("/api/posts", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ chain, token, wallet: address, parentId: replyTo, body: v.body, nonce: n, ts, signature }) });
+      const res = await fetch("/api/posts", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ chain, token, wallet: address, parentId: target, body: v.body, nonce: n, ts, signature }) });
       const d = (await res.json()) as { ok?: boolean; post?: PostRow; error?: string };
       if (!res.ok || !d.post) throw new Error(d.error ?? "post rejected");
       setPosts((cur) => [d.post!, ...cur]);
@@ -186,20 +199,24 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
           </div>
         ) : (
           <div className="space-y-2">
-            {replyTo !== null ? (
+            {effectiveReplyTo !== null ? (
               <p className="text-[11px] text-muted">
-                Replying to #{replyTo}{" "}
-                <button type="button" className="underline hover:text-ink" onClick={() => setReplyTo(null)}>
+                Replying to #{effectiveReplyTo}{" "}
+                <button type="button" className="underline hover:text-ink" onClick={() => { setReplyTo(null); saveDraft(chain, token, body, null); }}>
                   cancel
                 </button>
               </p>
+            ) : replyMissing ? (
+              <p className="text-[11px] text-muted" role="status">
+                The comment you were replying to is gone — posting as a top-level comment.
+              </p>
             ) : null}
             <textarea
               value={body}
               onChange={(e) => {
                 const next = e.target.value.slice(0, POST_MAX);
                 setBody(next);
-                saveDraft(chain, token, next);
+                saveDraft(chain, token, next, effectiveReplyTo);
               }}
               placeholder={`Say something about ${symbol}…`}
               aria-label={`Comment about ${symbol}`}
@@ -209,7 +226,7 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
             <div className="flex items-center justify-between gap-3">
               <span id={`comment-count-${chain}`} aria-live="polite" className="text-[11px] text-muted font-mono tnum">{POST_MAX - body.length}</span>
               <button type="button" onClick={() => void submit()} disabled={busy || !body.trim()} className={btn.primarySm}>
-                {busy ? "Sign in wallet…" : replyTo !== null ? "Reply" : "Post"}
+                {busy ? "Sign in wallet…" : effectiveReplyTo !== null ? "Reply" : "Post"}
               </button>
             </div>
             {err ? <p className="text-xs text-down-ink" role="alert">{err}</p> : null}
@@ -223,7 +240,7 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
           const thread = repliesById.get(p.id) ?? [];
           return (
           <li key={p.id} className="px-4 py-3">
-            <PostItem p={p} now={now} canReply={isConnected && !muted} onReply={() => setReplyTo(p.id)} onReport={address && p.wallet !== address.toLowerCase() ? (r) => void report(p, r) : undefined} />
+            <PostItem p={p} now={now} canReply={isConnected && !muted} onReply={() => { setReplyTo(p.id); saveDraft(chain, token, body, p.id); }} onReport={address && p.wallet !== address.toLowerCase() ? (r) => void report(p, r) : undefined} />
             {thread.length ? (
               <ul className="mt-2 ml-6 pl-3 border-l border-line space-y-2">
                 {thread.map((r) => (
diff --git a/app/src/lib/launchpad/post-threads.test.ts b/app/src/lib/launchpad/post-threads.test.ts
index bb7a0a96..7fd877bc 100644
--- a/app/src/lib/launchpad/post-threads.test.ts
+++ b/app/src/lib/launchpad/post-threads.test.ts
@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { COMMENTS_PAGE, clearDraft, draftKey, groupReplies, loadDraft, saveDraft, visibleTopIds } from "./post-threads.ts";
+import { COMMENTS_PAGE, clearDraft, draftKey, groupReplies, loadCommentDraft, loadDraft, saveDraft, visibleTopIds } from "./post-threads.ts";
 import type { PostRow } from "./postsServer.ts";
 
 const post = (id: number, parent_id: number | null): PostRow => ({ id, chain: "base", token: "0xtoken", wallet: "0xwallet", parent_id, body: `body ${id}`, tag: null, created_at: "2026-01-01T00:00:00.000Z", reports: 0, hidden: false });
@@ -36,3 +36,53 @@ test("draft key is per token and lowercase; node loads empty and saves are no-op
   clearDraft("base", "0xabc");
   assert.equal(loadDraft("base", "0xabc"), "", "no localStorage in node: always empty, never throws");
 });
+
+function withMemoryStorage(): Map<string, string> {
+  const store = new Map<string, string>();
+  const g = globalThis as Record<string, unknown>;
+  g.localStorage = {
+    getItem: (k: string) => (store.has(k) ? store.get(k)! : null),
+    setItem: (k: string, v: string) => void store.set(k, String(v)),
+    removeItem: (k: string) => void store.delete(k),
+  };
+  return store;
+}
+
+function withoutStorage(): void {
+  const g = globalThis as Record<string, unknown>;
+  delete g.localStorage;
+}
+
+test("draft restores both a top-level draft and a reply draft (PR #31)", () => {
+  const store = withMemoryStorage();
+  try {
+    saveDraft("base", "0xabc", "top-level hello");
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "top-level hello", parentId: null });
+    assert.equal(loadDraft("base", "0xabc"), "top-level hello");
+
+    saveDraft("base", "0xabc", "reply hello", 42);
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "reply hello", parentId: 42 });
+
+    clearDraft("base", "0xabc");
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null });
+    assert.equal(store.size, 0);
+  } finally {
+    withoutStorage();
+  }
+});
+
+test("draft understands legacy plain-text drafts and rejects bad parent ids", () => {
+  const store = withMemoryStorage();
+  try {
+    store.set(draftKey("base", "0xabc"), "legacy hello");
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "legacy hello", parentId: null });
+
+    store.set(draftKey("base", "0xabc"), JSON.stringify({ body: "x", parentId: -7 }));
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "x", parentId: null });
+
+    store.set(draftKey("base", "0xabc"), JSON.stringify({ body: "x", parentId: "42" }));
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "x", parentId: null });
+  } finally {
+    withoutStorage();
+  }
+});
diff --git a/app/src/lib/launchpad/post-threads.ts b/app/src/lib/launchpad/post-threads.ts
index 8a2cf268..0a743836 100644
--- a/app/src/lib/launchpad/post-threads.ts
+++ b/app/src/lib/launchpad/post-threads.ts
@@ -36,20 +36,43 @@ export function draftKey(chain: string, token: string): string {
   return `ol:comment-draft:${chain}:${token.toLowerCase()}`;
 }
 
-export function loadDraft(chain: string, token: string): string {
+/** Composer draft: body plus the reply destination (null = top-level post). */
+export type CommentDraft = { body: string; parentId: number | null };
+
+function cleanParentId(v: unknown): number | null {
+  return typeof v === "number" && Number.isInteger(v) && v > 0 ? v : null;
+}
+
+/** Load the full draft (body + reply target). Understands the new JSON shape and legacy plain-text drafts. */
+export function loadCommentDraft(chain: string, token: string): CommentDraft {
   try {
-    if (typeof localStorage === "undefined") return "";
-    return localStorage.getItem(draftKey(chain, token)) ?? "";
+    if (typeof localStorage === "undefined") return { body: "", parentId: null };
+    const raw = localStorage.getItem(draftKey(chain, token));
+    if (!raw) return { body: "", parentId: null };
+    try {
+      const parsed = JSON.parse(raw) as { body?: unknown; parentId?: unknown };
+      if (parsed && typeof parsed === "object" && typeof parsed.body === "string") {
+        return { body: parsed.body, parentId: cleanParentId(parsed.parentId) };
+      }
+    } catch {
+      /* legacy plain-text draft falls through */
+    }
+    return { body: raw, parentId: null };
   } catch {
-    return "";
+    return { body: "", parentId: null };
   }
 }
 
-export function saveDraft(chain: string, token: string, body: string): void {
+export function loadDraft(chain: string, token: string): string {
+  return loadCommentDraft(chain, token).body;
+}
+
+export function saveDraft(chain: string, token: string, body: string, parentId: number | null = null): void {
   try {
     if (typeof localStorage === "undefined") return;
-    if (!body) localStorage.removeItem(draftKey(chain, token));
-    else localStorage.setItem(draftKey(chain, token), body.slice(0, 2000));
+    const pid = cleanParentId(parentId);
+    if (!body && pid === null) localStorage.removeItem(draftKey(chain, token));
+    else localStorage.setItem(draftKey(chain, token), JSON.stringify({ body: body.slice(0, 2000), parentId: pid }));
   } catch {
     /* storage blocked: the in-memory textarea state is what survives */
   }

From 1bbc7da82203dd4d28e67560aa1a249e69df0014 Mon Sep 17 00:00:00 2001
From: Ayush7614 <ayushknj3@gmail.com>
Date: Sat, 12 Sep 2026 18:11:21 +0530
Subject: [PATCH 4/8] fix(posts): gate restored replies on initial load so
 missing parents post top-level (PR #31)

- track postsLoaded; restored replyTo is pending until first load settles
- resolveReplyTarget validates even on empty list, falls back to null (no 404)
- submit blocks while pending; composer shows checking/gone states
---
 app/src/components/launchpad/Posts.tsx     | 41 ++++++++++++++++------
 app/src/lib/launchpad/post-threads.test.ts | 11 +++++-
 app/src/lib/launchpad/post-threads.ts      | 21 +++++++++++
 3 files changed, 61 insertions(+), 12 deletions(-)

diff --git a/app/src/components/launchpad/Posts.tsx b/app/src/components/launchpad/Posts.tsx
index c22544e8..67f43289 100644
--- a/app/src/components/launchpad/Posts.tsx
+++ b/app/src/components/launchpad/Posts.tsx
@@ -10,7 +10,7 @@ import { useLive } from "./LiveProvider";
 import { toast } from "./TxToasts";
 import { btn } from "@/components/ui";
 import { buildModMessage, buildPostMessage, buildReportMessage, POST_MAX, REPORT_REASONS, validateBody, type ReportReason } from "@/lib/launchpad/posts";
-import { COMMENTS_PAGE, clearDraft, groupReplies, loadCommentDraft, saveDraft, visibleTopIds } from "@/lib/launchpad/post-threads";
+import { COMMENTS_PAGE, clearDraft, groupReplies, loadCommentDraft, resolveReplyTarget, saveDraft, visibleTopIds } from "@/lib/launchpad/post-threads";
 import type { PostRow } from "@/lib/launchpad/postsServer";
 import { ago, nowMs } from "@/lib/launchpad/time";
 import { CHAINS, CHAIN_SHORT, shortAddr, type ChainKey } from "@/lib/chainPublic";
@@ -53,6 +53,11 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
   const [err, setErr] = useState<string | null>(null);
   const [now, setNow] = useState(0);
   const [shownCount, setShownCount] = useState(COMMENTS_PAGE);
+  // True once the first load() for the current chain/token has settled.
+  // A restored replyTo cannot be validated until then: posts starts empty, so
+  // an empty list must not read as "parent missing" before the fetch, nor as
+  // "parent exists" for signing. Submit of a restored reply blocks meanwhile.
+  const [postsLoaded, setPostsLoaded] = useState(false);
   // Draft restores async after hydration so server and client render the same empty composer first.
   // The loaded value is always assigned (even when empty) so text typed for one
   // token can never leak into — and be submitted from — another token's composer.
@@ -64,6 +69,9 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
       setBody(d.body.slice(0, POST_MAX));
       setReplyTo(d.parentId);
       setShownCount(COMMENTS_PAGE);
+      setPosts([]);
+      setPostsLoaded(false);
+      setErr(null);
     }, 0);
     return () => clearTimeout(t);
   }, [chain, token]);
@@ -80,6 +88,8 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
       setNow(nowMs());
     } catch {
       /* keep */
+    } finally {
+      setPostsLoaded(true);
     }
   }, [chain, token]);
 
@@ -102,11 +112,11 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
   );
 
   // A restored reply target may be gone (hidden, deleted, or another token's
-  // id). Derive the effective target during render so the draft posts
-  // top-level instead of 404ing — no set-state-in-effect, no flash of a stale
-  // "Replying to #". Before posts load we assume the target exists.
-  const replyMissing = replyTo !== null && posts.length > 0 && !posts.some((p) => p.id === replyTo);
-  const effectiveReplyTo = replyMissing ? null : replyTo;
+  // id). Resolve during render so the draft posts top-level instead of 404ing
+  // — no set-state-in-effect. Validation runs only after the first load
+  // settles, even when the loaded list is empty; before that a restored reply
+  // is pending and submit blocks instead of signing an unvalidated parent.
+  const { target: effectiveReplyTo, pending: validationPending, missing: replyMissing } = resolveReplyTarget(replyTo, posts, postsLoaded);
 
   async function submit() {
     if (!address) return;
@@ -115,8 +125,13 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
       setErr(v.error);
       return;
     }
-    // Re-derive here: posts may have changed since the last render.
-    const target = replyTo !== null && posts.length > 0 && !posts.some((p) => p.id === replyTo) ? null : replyTo;
+    // Re-resolve here: posts may have changed since the last render.
+    const resolved = resolveReplyTarget(replyTo, posts, postsLoaded);
+    if (resolved.pending) {
+      setErr("Loading comments — please try again in a moment.");
+      return;
+    }
+    const target = resolved.target;
     setBusy(true);
     setErr(null);
     try {
@@ -199,7 +214,11 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
           </div>
         ) : (
           <div className="space-y-2">
-            {effectiveReplyTo !== null ? (
+            {validationPending ? (
+              <p className="text-[11px] text-muted" role="status">
+                Checking reply target…
+              </p>
+            ) : effectiveReplyTo !== null ? (
               <p className="text-[11px] text-muted">
                 Replying to #{effectiveReplyTo}{" "}
                 <button type="button" className="underline hover:text-ink" onClick={() => { setReplyTo(null); saveDraft(chain, token, body, null); }}>
@@ -225,8 +244,8 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
             />
             <div className="flex items-center justify-between gap-3">
               <span id={`comment-count-${chain}`} aria-live="polite" className="text-[11px] text-muted font-mono tnum">{POST_MAX - body.length}</span>
-              <button type="button" onClick={() => void submit()} disabled={busy || !body.trim()} className={btn.primarySm}>
-                {busy ? "Sign in wallet…" : effectiveReplyTo !== null ? "Reply" : "Post"}
+              <button type="button" onClick={() => void submit()} disabled={busy || !body.trim() || validationPending} className={btn.primarySm}>
+                {busy ? "Sign in wallet…" : validationPending ? "Checking…" : effectiveReplyTo !== null ? "Reply" : "Post"}
               </button>
             </div>
             {err ? <p className="text-xs text-down-ink" role="alert">{err}</p> : null}
diff --git a/app/src/lib/launchpad/post-threads.test.ts b/app/src/lib/launchpad/post-threads.test.ts
index 7fd877bc..7044df66 100644
--- a/app/src/lib/launchpad/post-threads.test.ts
+++ b/app/src/lib/launchpad/post-threads.test.ts
@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { COMMENTS_PAGE, clearDraft, draftKey, groupReplies, loadCommentDraft, loadDraft, saveDraft, visibleTopIds } from "./post-threads.ts";
+import { COMMENTS_PAGE, clearDraft, draftKey, groupReplies, loadCommentDraft, loadDraft, resolveReplyTarget, saveDraft, visibleTopIds } from "./post-threads.ts";
 import type { PostRow } from "./postsServer.ts";
 
 const post = (id: number, parent_id: number | null): PostRow => ({ id, chain: "base", token: "0xtoken", wallet: "0xwallet", parent_id, body: `body ${id}`, tag: null, created_at: "2026-01-01T00:00:00.000Z", reports: 0, hidden: false });
@@ -86,3 +86,12 @@ test("draft understands legacy plain-text drafts and rejects bad parent ids", ()
     withoutStorage();
   }
 });
+
+test("resolveReplyTarget blocks before first load and falls back on empty/missing parents (PR #31)", () => {
+  assert.deepEqual(resolveReplyTarget(null, [], false), { target: null, pending: false, missing: false }, "top-level never blocks");
+  assert.deepEqual(resolveReplyTarget(null, [], true), { target: null, pending: false, missing: false });
+  assert.deepEqual(resolveReplyTarget(42, [], false), { target: 42, pending: true, missing: false }, "restored reply is pending before validation, never signed");
+  assert.deepEqual(resolveReplyTarget(42, [], true), { target: null, pending: false, missing: true }, "empty loaded list means the parent is gone → top-level");
+  assert.deepEqual(resolveReplyTarget(42, [{ id: 42 }], true), { target: 42, pending: false, missing: false }, "present parent stays a reply");
+  assert.deepEqual(resolveReplyTarget(42, [{ id: 7 }], true), { target: null, pending: false, missing: true }, "hidden/deleted parent falls back instead of 404ing");
+});
diff --git a/app/src/lib/launchpad/post-threads.ts b/app/src/lib/launchpad/post-threads.ts
index 0a743836..659c3018 100644
--- a/app/src/lib/launchpad/post-threads.ts
+++ b/app/src/lib/launchpad/post-threads.ts
@@ -86,3 +86,24 @@ export function clearDraft(chain: string, token: string): void {
     /* ignore */
   }
 }
+
+/**
+ * Resolve a restored reply target against the loaded posts (PR #31).
+ *
+ * Draft restoration and the initial posts fetch race: posts starts empty, so
+ * an empty list must not read as "parent missing" before the fetch, nor as
+ * "parent exists" for signing. While !postsLoaded a non-null replyTo is
+ * pending (caller blocks submit instead of signing an unvalidated parent);
+ * after loading, membership decides — even when the list is empty — and a
+ * missing/hidden parent falls back to null (top-level).
+ */
+export function resolveReplyTarget(
+  replyTo: number | null,
+  posts: readonly { id: number }[],
+  postsLoaded: boolean,
+): { target: number | null; pending: boolean; missing: boolean } {
+  if (replyTo === null) return { target: null, pending: false, missing: false };
+  if (!postsLoaded) return { target: replyTo, pending: true, missing: false };
+  if (posts.some((p) => p.id === replyTo)) return { target: replyTo, pending: false, missing: false };
+  return { target: null, pending: false, missing: true };
+}

From 990495a1d5a7435b974fe6eb70cd2f6c33de3d60 Mon Sep 17 00:00:00 2001
From: Ayush7614 <ayushknj3@gmail.com>
Date: Sun, 13 Sep 2026 10:52:12 +0530
Subject: [PATCH 5/8] fix(posts): keep reply target on fetch failure and
 preserve outside truncated window (PR #31)

- Posts.tsx load(): only set postsLoaded after a successful, validated response. A 503 or network rejection no longer marks validation complete with an empty posts array, so a restored reply stays pending (blocks submit) and the draft is not silently turned into a top-level post.
- post-threads.ts resolveReplyTarget(): the posts endpoint returns only the latest 100 rows, so absence in the window is not proof the parent was deleted. Preserve the saved reply target after load (no auto fallback to null); server will reject if truly gone. Adds regression for parent ID 100 with window 200..101.

Verified: post-threads suite 8/8, tsc --noEmit pass, lint pass, build pass.
---
 app/src/components/launchpad/Posts.tsx     | 16 ++++++++--------
 app/src/lib/launchpad/post-threads.test.ts | 17 ++++++++++++++---
 app/src/lib/launchpad/post-threads.ts      | 16 +++++++++++-----
 3 files changed, 33 insertions(+), 16 deletions(-)

diff --git a/app/src/components/launchpad/Posts.tsx b/app/src/components/launchpad/Posts.tsx
index 67f43289..e3a2cb99 100644
--- a/app/src/components/launchpad/Posts.tsx
+++ b/app/src/components/launchpad/Posts.tsx
@@ -83,13 +83,13 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
       const res = await fetch(`/api/posts?chain=${chain}&token=${token}`, { cache: "no-store" });
       if (!res.ok) return;
       const d = (await res.json()) as { posts: PostRow[]; muted: boolean };
+      if (!Array.isArray(d.posts)) return;
       setPosts(d.posts);
       setMuted(d.muted);
       setNow(nowMs());
-    } catch {
-      /* keep */
-    } finally {
       setPostsLoaded(true);
+    } catch {
+      /* keep postsLoaded false so a restored reply stays pending and the draft isn't lost (503 / network rejection) */
     }
   }, [chain, token]);
 
@@ -111,11 +111,11 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
     [subscribe, chain, token, load],
   );
 
-  // A restored reply target may be gone (hidden, deleted, or another token's
-  // id). Resolve during render so the draft posts top-level instead of 404ing
-  // — no set-state-in-effect. Validation runs only after the first load
-  // settles, even when the loaded list is empty; before that a restored reply
-  // is pending and submit blocks instead of signing an unvalidated parent.
+  // A restored reply target is validated only after the first successful load.
+  // Before that a restored reply is pending and submit blocks instead of signing
+  // an unvalidated parent. After load the truncated posts window (latest 100) is
+  // not authoritative — a missing id there does not mean the parent is gone, so
+  // we preserve the target and let the server decide (no silent top-level fallback).
   const { target: effectiveReplyTo, pending: validationPending, missing: replyMissing } = resolveReplyTarget(replyTo, posts, postsLoaded);
 
   async function submit() {
diff --git a/app/src/lib/launchpad/post-threads.test.ts b/app/src/lib/launchpad/post-threads.test.ts
index 7044df66..19308f2c 100644
--- a/app/src/lib/launchpad/post-threads.test.ts
+++ b/app/src/lib/launchpad/post-threads.test.ts
@@ -87,11 +87,22 @@ test("draft understands legacy plain-text drafts and rejects bad parent ids", ()
   }
 });
 
-test("resolveReplyTarget blocks before first load and falls back on empty/missing parents (PR #31)", () => {
+test("resolveReplyTarget blocks before first load and preserves reply when posts window is truncated (PR #31)", () => {
   assert.deepEqual(resolveReplyTarget(null, [], false), { target: null, pending: false, missing: false }, "top-level never blocks");
   assert.deepEqual(resolveReplyTarget(null, [], true), { target: null, pending: false, missing: false });
   assert.deepEqual(resolveReplyTarget(42, [], false), { target: 42, pending: true, missing: false }, "restored reply is pending before validation, never signed");
-  assert.deepEqual(resolveReplyTarget(42, [], true), { target: null, pending: false, missing: true }, "empty loaded list means the parent is gone → top-level");
+  // After a successful load the posts window is truncated (latest 100). Absence there is not proof the parent was deleted.
+  assert.deepEqual(resolveReplyTarget(42, [], true), { target: 42, pending: false, missing: false }, "empty window is not proof parent is gone — preserve");
   assert.deepEqual(resolveReplyTarget(42, [{ id: 42 }], true), { target: 42, pending: false, missing: false }, "present parent stays a reply");
-  assert.deepEqual(resolveReplyTarget(42, [{ id: 7 }], true), { target: null, pending: false, missing: true }, "hidden/deleted parent falls back instead of 404ing");
+  assert.deepEqual(resolveReplyTarget(42, [{ id: 7 }], true), { target: 42, pending: false, missing: false }, "parent not in truncated window preserves target");
+});
+
+test("resolveReplyTarget preserves valid parent outside returned window (PR #31 regression)", () => {
+  // Saved reply to 100, response contains only 200..101 — parent still exists but is outside the window.
+  const window = Array.from({ length: 100 }, (_, i) => ({ id: 200 - i }));
+  assert.equal(window.some((p) => p.id === 100), false, "100 is outside the latest-100 window");
+  assert.deepEqual(resolveReplyTarget(100, window, true), { target: 100, pending: false, missing: false }, "valid parent outside window must not become top-level");
+  // Before validation (postsLoaded false) the same draft stays pending even on failure (503 / network rejection) — no silent fallback
+  assert.deepEqual(resolveReplyTarget(100, [], false), { target: 100, pending: true, missing: false }, "failed/no-load keeps pending so draft isn't lost");
+  assert.deepEqual(resolveReplyTarget(100, window, false), { target: 100, pending: true, missing: false });
 });
diff --git a/app/src/lib/launchpad/post-threads.ts b/app/src/lib/launchpad/post-threads.ts
index 659c3018..e04a4a30 100644
--- a/app/src/lib/launchpad/post-threads.ts
+++ b/app/src/lib/launchpad/post-threads.ts
@@ -93,9 +93,13 @@ export function clearDraft(chain: string, token: string): void {
  * Draft restoration and the initial posts fetch race: posts starts empty, so
  * an empty list must not read as "parent missing" before the fetch, nor as
  * "parent exists" for signing. While !postsLoaded a non-null replyTo is
- * pending (caller blocks submit instead of signing an unvalidated parent);
- * after loading, membership decides — even when the list is empty — and a
- * missing/hidden parent falls back to null (top-level).
+ * pending (caller blocks submit instead of signing an unvalidated parent).
+ *
+ * After loading the posts window is truncated (latest 100 rows). Absence in
+ * that window is not authoritative evidence the parent was deleted/hidden, so
+ * we preserve the saved destination and let the server reject it if truly gone.
+ * No silent top-level fallback — the user keeps their intended reply target
+ * unless we have checked it authoritatively.
  */
 export function resolveReplyTarget(
   replyTo: number | null,
@@ -104,6 +108,8 @@ export function resolveReplyTarget(
 ): { target: number | null; pending: boolean; missing: boolean } {
   if (replyTo === null) return { target: null, pending: false, missing: false };
   if (!postsLoaded) return { target: replyTo, pending: true, missing: false };
-  if (posts.some((p) => p.id === replyTo)) return { target: replyTo, pending: false, missing: false };
-  return { target: null, pending: false, missing: true };
+  // Window is truncated: missing from the latest 100 does not mean deleted.
+  // Preserve the target; server will return 404 if truly gone and the UI will
+  // surface that error instead of silently changing the destination.
+  return { target: replyTo, pending: false, missing: false };
 }

From 64032400b415744b2120d04a3f98aea97314650f Mon Sep 17 00:00:00 2001
From: Ayush7614 <ayushknj3@gmail.com>
Date: Mon, 14 Sep 2026 12:52:16 +0530
Subject: [PATCH 6/8] fix(posts): abort stale comment loads on token switch
 (CodeRabbit, PR #31)

In-flight fetch for token A could resolve after switching to token B and overwrite B's posts / postsLoaded, unblocking reply submit early. Guard every state update with generation + AbortController (same pattern as PriceChart); cleanup aborts and bumps generation.
---
 app/src/components/launchpad/Posts.tsx | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/app/src/components/launchpad/Posts.tsx b/app/src/components/launchpad/Posts.tsx
index e3a2cb99..facff3e3 100644
--- a/app/src/components/launchpad/Posts.tsx
+++ b/app/src/components/launchpad/Posts.tsx
@@ -77,25 +77,41 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
   }, [chain, token]);
   const seenPosts = useRef<string>("");
   const isCreator = Boolean(address && address.toLowerCase() === launcher.toLowerCase());
+  // Guard against stale loads: a fetch for token A resolving after the switch
+  // to token B must not overwrite B's posts or unblock B's reply validation.
+  // Same generation + AbortController pattern as PriceChart.
+  const request = useRef<AbortController | null>(null);
+  const generation = useRef(0);
 
   const load = useCallback(async () => {
+    const id = ++generation.current;
+    request.current?.abort();
+    const controller = new AbortController();
+    request.current = controller;
     try {
-      const res = await fetch(`/api/posts?chain=${chain}&token=${token}`, { cache: "no-store" });
+      const res = await fetch(`/api/posts?chain=${chain}&token=${token}`, { cache: "no-store", signal: controller.signal });
       if (!res.ok) return;
       const d = (await res.json()) as { posts: PostRow[]; muted: boolean };
       if (!Array.isArray(d.posts)) return;
+      if (id !== generation.current || controller.signal.aborted) return;
       setPosts(d.posts);
       setMuted(d.muted);
       setNow(nowMs());
       setPostsLoaded(true);
     } catch {
+      if (id !== generation.current || controller.signal.aborted) return;
       /* keep postsLoaded false so a restored reply stays pending and the draft isn't lost (503 / network rejection) */
     }
   }, [chain, token]);
 
   useEffect(() => {
-    const id = setTimeout(() => void load(), 0);
-    return () => clearTimeout(id);
+    const lifetime = generation;
+    const timer = setTimeout(() => void load(), 0);
+    return () => {
+      clearTimeout(timer);
+      lifetime.current++;
+      request.current?.abort();
+    };
   }, [load]);
   // refresh when the shared poller says there is a newer post on this token
   useEffect(

From 62ae84df33827902fb31053496b506269f9c5074 Mon Sep 17 00:00:00 2001
From: Ayush7614 <ayushknj3@gmail.com>
Date: Mon, 14 Sep 2026 12:59:43 +0530
Subject: [PATCH 7/8] fix(posts): retry/cancel recovery for failed reply-target
 load (PR #31)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A restored reply draft plus a failed initial fetch (503/network) left the composer stuck on 'Checking reply target...' with submit disabled and no Cancel or Retry — load() only retried via the live feed, so a quiet token never recovered.

- post-threads.ts: add shouldIgnoreLoad stale-guard predicate and nextPostsLoadState reducer (failure keeps postsLoaded false + arms loadError, preserving body+parentId; only ok flips loaded; ignored leaves state untouched).
- Posts.tsx: load() sets loadError on HTTP/invalid/network failure via the reducer (stale/abort still ignored); composer pending branch keeps Cancel available and shows Try again on failure. Retry re-calls load() without touching the draft.
- post-threads.test.ts: cover out-of-order stale-ignore and 503/network recovery (pending preserved, retry recovers, ignored is a no-op).

Verified: post-threads 10/10, tsc pass, lint clean, build pass.
---
 app/src/components/launchpad/Posts.tsx     | 53 ++++++++++++++++++----
 app/src/lib/launchpad/post-threads.test.ts | 30 +++++++++++-
 app/src/lib/launchpad/post-threads.ts      | 49 ++++++++++++++++++++
 3 files changed, 122 insertions(+), 10 deletions(-)

diff --git a/app/src/components/launchpad/Posts.tsx b/app/src/components/launchpad/Posts.tsx
index facff3e3..02ac4012 100644
--- a/app/src/components/launchpad/Posts.tsx
+++ b/app/src/components/launchpad/Posts.tsx
@@ -10,7 +10,7 @@ import { useLive } from "./LiveProvider";
 import { toast } from "./TxToasts";
 import { btn } from "@/components/ui";
 import { buildModMessage, buildPostMessage, buildReportMessage, POST_MAX, REPORT_REASONS, validateBody, type ReportReason } from "@/lib/launchpad/posts";
-import { COMMENTS_PAGE, clearDraft, groupReplies, loadCommentDraft, resolveReplyTarget, saveDraft, visibleTopIds } from "@/lib/launchpad/post-threads";
+import { COMMENTS_PAGE, clearDraft, groupReplies, loadCommentDraft, nextPostsLoadState, resolveReplyTarget, saveDraft, shouldIgnoreLoad, visibleTopIds } from "@/lib/launchpad/post-threads";
 import type { PostRow } from "@/lib/launchpad/postsServer";
 import { ago, nowMs } from "@/lib/launchpad/time";
 import { CHAINS, CHAIN_SHORT, shortAddr, type ChainKey } from "@/lib/chainPublic";
@@ -58,6 +58,10 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
   // an empty list must not read as "parent missing" before the fetch, nor as
   // "parent exists" for signing. Submit of a restored reply blocks meanwhile.
   const [postsLoaded, setPostsLoaded] = useState(false);
+  // Set when the initial comments fetch fails (503 / network rejection / bad
+  // payload). postsLoaded stays false so a restored reply keeps pending and
+  // the draft is never silently turned top-level; the composer shows Retry.
+  const [loadError, setLoadError] = useState<string | null>(null);
   // Draft restores async after hydration so server and client render the same empty composer first.
   // The loaded value is always assigned (even when empty) so text typed for one
   // token can never leak into — and be submitted from — another token's composer.
@@ -71,6 +75,7 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
       setShownCount(COMMENTS_PAGE);
       setPosts([]);
       setPostsLoaded(false);
+      setLoadError(null);
       setErr(null);
     }, 0);
     return () => clearTimeout(t);
@@ -88,19 +93,31 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
     request.current?.abort();
     const controller = new AbortController();
     request.current = controller;
+    const ignored = () => shouldIgnoreLoad(id, generation.current, controller.signal.aborted);
     try {
       const res = await fetch(`/api/posts?chain=${chain}&token=${token}`, { cache: "no-store", signal: controller.signal });
-      if (!res.ok) return;
+      if (ignored()) return;
+      if (!res.ok) {
+        // Failure, not proof of anything: keep postsLoaded false so a restored
+        // reply stays pending (submit blocks) and the draft keeps its destination.
+        setLoadError(nextPostsLoadState({ postsLoaded: false, loadError: null }, { kind: "http-error", status: res.status }).loadError);
+        return;
+      }
       const d = (await res.json()) as { posts: PostRow[]; muted: boolean };
-      if (!Array.isArray(d.posts)) return;
-      if (id !== generation.current || controller.signal.aborted) return;
+      if (!Array.isArray(d.posts)) {
+        if (ignored()) return;
+        setLoadError(nextPostsLoadState({ postsLoaded: false, loadError: null }, { kind: "invalid" }).loadError);
+        return;
+      }
+      if (ignored()) return;
       setPosts(d.posts);
       setMuted(d.muted);
       setNow(nowMs());
       setPostsLoaded(true);
+      setLoadError(null);
     } catch {
-      if (id !== generation.current || controller.signal.aborted) return;
-      /* keep postsLoaded false so a restored reply stays pending and the draft isn't lost (503 / network rejection) */
+      if (ignored()) return;
+      setLoadError(nextPostsLoadState({ postsLoaded: false, loadError: null }, { kind: "network-error" }).loadError);
     }
   }, [chain, token]);
 
@@ -231,9 +248,27 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
         ) : (
           <div className="space-y-2">
             {validationPending ? (
-              <p className="text-[11px] text-muted" role="status">
-                Checking reply target…
-              </p>
+              <div className="space-y-1">
+                <p className="text-[11px] text-muted" role="status">
+                  Checking reply target…
+                </p>
+                {replyTo !== null ? (
+                  <p className="text-[11px] text-muted">
+                    Replying to #{replyTo}{" "}
+                    <button type="button" className="underline hover:text-ink" onClick={() => { setReplyTo(null); saveDraft(chain, token, body, null); }}>
+                      cancel
+                    </button>
+                  </p>
+                ) : null}
+                {loadError ? (
+                  <p className="text-[11px] text-down-ink" role="alert">
+                    {loadError}{" "}
+                    <button type="button" className="underline hover:text-ink" onClick={() => { setLoadError(null); void load(); }}>
+                      Try again
+                    </button>
+                  </p>
+                ) : null}
+              </div>
             ) : effectiveReplyTo !== null ? (
               <p className="text-[11px] text-muted">
                 Replying to #{effectiveReplyTo}{" "}
diff --git a/app/src/lib/launchpad/post-threads.test.ts b/app/src/lib/launchpad/post-threads.test.ts
index 19308f2c..533f364a 100644
--- a/app/src/lib/launchpad/post-threads.test.ts
+++ b/app/src/lib/launchpad/post-threads.test.ts
@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { COMMENTS_PAGE, clearDraft, draftKey, groupReplies, loadCommentDraft, loadDraft, resolveReplyTarget, saveDraft, visibleTopIds } from "./post-threads.ts";
+import { COMMENTS_PAGE, clearDraft, draftKey, groupReplies, initialPostsLoadState, loadCommentDraft, loadDraft, nextPostsLoadState, resolveReplyTarget, saveDraft, shouldIgnoreLoad, visibleTopIds } from "./post-threads.ts";
 import type { PostRow } from "./postsServer.ts";
 
 const post = (id: number, parent_id: number | null): PostRow => ({ id, chain: "base", token: "0xtoken", wallet: "0xwallet", parent_id, body: `body ${id}`, tag: null, created_at: "2026-01-01T00:00:00.000Z", reports: 0, hidden: false });
@@ -106,3 +106,31 @@ test("resolveReplyTarget preserves valid parent outside returned window (PR #31
   assert.deepEqual(resolveReplyTarget(100, [], false), { target: 100, pending: true, missing: false }, "failed/no-load keeps pending so draft isn't lost");
   assert.deepEqual(resolveReplyTarget(100, window, false), { target: 100, pending: true, missing: false });
 });
+
+test("shouldIgnoreLoad drops stale/aborted responses so token A cannot overwrite token B (PR #31)", () => {
+  // Token A starts load id 1; switching to B bumps generation to 2 and aborts A.
+  assert.equal(shouldIgnoreLoad(1, 1, false), false, "current generation, live request: apply");
+  assert.equal(shouldIgnoreLoad(1, 2, false), true, "older request resolving after token switch: ignore");
+  assert.equal(shouldIgnoreLoad(1, 2, true), true, "aborted request: ignore");
+  assert.equal(shouldIgnoreLoad(2, 2, true), true, "current generation but aborted: ignore");
+  assert.equal(shouldIgnoreLoad(2, 2, false), false, "newer request for the current token: apply");
+});
+
+test("nextPostsLoadState keeps a restored reply pending with Retry after 503/network failure (PR #31)", () => {
+  // Initial 503: postsLoaded stays false (reply stays pending, submit blocks), error arms Retry.
+  const after503 = nextPostsLoadState(initialPostsLoadState, { kind: "http-error", status: 503 });
+  assert.deepEqual(after503, { postsLoaded: false, loadError: "Could not load comments (503)." });
+  assert.deepEqual(resolveReplyTarget(42, [], after503.postsLoaded), { target: 42, pending: true, missing: false }, "draft destination preserved, still pending — never silently top-level");
+
+  // Network rejection: same shape, connection hint.
+  const afterNet = nextPostsLoadState(initialPostsLoadState, { kind: "network-error" });
+  assert.deepEqual(afterNet, { postsLoaded: false, loadError: "Could not load comments. Check your connection." });
+  assert.deepEqual(resolveReplyTarget(42, [], afterNet.postsLoaded), { target: 42, pending: true, missing: false });
+
+  // Retry succeeding clears the error and unblocks validation.
+  const recovered = nextPostsLoadState(after503, { kind: "ok" });
+  assert.deepEqual(recovered, { postsLoaded: true, loadError: null });
+
+  // Abort/stale completion leaves failure state untouched (no error wipe, no phantom load).
+  assert.equal(nextPostsLoadState(after503, { kind: "ignored" }), after503, "ignored outcomes return prev state");
+});
diff --git a/app/src/lib/launchpad/post-threads.ts b/app/src/lib/launchpad/post-threads.ts
index e04a4a30..d772b14c 100644
--- a/app/src/lib/launchpad/post-threads.ts
+++ b/app/src/lib/launchpad/post-threads.ts
@@ -113,3 +113,52 @@ export function resolveReplyTarget(
   // surface that error instead of silently changing the destination.
   return { target: replyTo, pending: false, missing: false };
 }
+
+/**
+ * Stale-load guard for TokenComments (PR #31).
+ *
+ * A fetch for token A resolving after the switch to token B must not touch
+ * B's posts or postsLoaded. The component bumps a generation counter on every
+ * token switch / cleanup and aborts the previous request; each load captures
+ * its id up front and checks this predicate before any state update. Pure so
+ * the out-of-order scenario is unit-testable without mounting the component
+ * (the repo harness is node:test on pure helpers, no React/jsdom setup).
+ */
+export function shouldIgnoreLoad(entryId: number, currentGeneration: number, aborted: boolean): boolean {
+  return aborted || entryId !== currentGeneration;
+}
+
+/** First-load status for the comments list. loadError set => Retry shown; postsLoaded stays false so a restored reply keeps pending (never silently top-level). */
+export type PostsLoadState = { postsLoaded: boolean; loadError: string | null };
+
+export const initialPostsLoadState: PostsLoadState = { postsLoaded: false, loadError: null };
+
+export type PostsLoadOutcome =
+  | { kind: "ok" }
+  | { kind: "http-error"; status: number }
+  | { kind: "invalid" }
+  | { kind: "network-error" }
+  | { kind: "ignored" };
+
+/**
+ * Reducer for the initial comments fetch (PR #31).
+ *
+ * Failure paths preserve the draft and its reply destination: postsLoaded
+ * stays false (restored reply keeps pending, submit keeps blocking) and a
+ * loadError message arms the Retry button. Only "ok" flips postsLoaded and
+ * clears the error; "ignored" (abort/stale) leaves state untouched.
+ */
+export function nextPostsLoadState(prev: PostsLoadState, outcome: PostsLoadOutcome): PostsLoadState {
+  switch (outcome.kind) {
+    case "ok":
+      return { postsLoaded: true, loadError: null };
+    case "http-error":
+      return { postsLoaded: false, loadError: `Could not load comments (${outcome.status}).` };
+    case "invalid":
+      return { postsLoaded: false, loadError: "Could not load comments." };
+    case "network-error":
+      return { postsLoaded: false, loadError: "Could not load comments. Check your connection." };
+    case "ignored":
+      return prev;
+  }
+}

From 39763000dba13c6a5bcbdea3780339adac269420 Mon Sep 17 00:00:00 2001
From: Ayush7614 <ayushknj3@gmail.com>
Date: Tue, 15 Sep 2026 14:20:25 +0530
Subject: [PATCH 8/8] fix(posts): address review 5206157230 dead code,
 aria-live, reply draft nits

---
 app/src/components/launchpad/Posts.tsx     | 43 ++++++++----------
 app/src/lib/launchpad/post-threads.test.ts | 52 +++++++++++-----------
 app/src/lib/launchpad/post-threads.ts      | 35 ++++++++-------
 3 files changed, 63 insertions(+), 67 deletions(-)

diff --git a/app/src/components/launchpad/Posts.tsx b/app/src/components/launchpad/Posts.tsx
index 02ac4012..0570cca4 100644
--- a/app/src/components/launchpad/Posts.tsx
+++ b/app/src/components/launchpad/Posts.tsx
@@ -10,7 +10,7 @@ import { useLive } from "./LiveProvider";
 import { toast } from "./TxToasts";
 import { btn } from "@/components/ui";
 import { buildModMessage, buildPostMessage, buildReportMessage, POST_MAX, REPORT_REASONS, validateBody, type ReportReason } from "@/lib/launchpad/posts";
-import { COMMENTS_PAGE, clearDraft, groupReplies, loadCommentDraft, nextPostsLoadState, resolveReplyTarget, saveDraft, shouldIgnoreLoad, visibleTopIds } from "@/lib/launchpad/post-threads";
+import { COMMENTS_PAGE, clearDraft, groupReplies, initialPostsLoadState, loadCommentDraft, nextPostsLoadState, resolveReplyTarget, saveDraft, shouldIgnoreLoad, visibleTopIds } from "@/lib/launchpad/post-threads";
 import type { PostRow } from "@/lib/launchpad/postsServer";
 import { ago, nowMs } from "@/lib/launchpad/time";
 import { CHAINS, CHAIN_SHORT, shortAddr, type ChainKey } from "@/lib/chainPublic";
@@ -57,11 +57,9 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
   // A restored replyTo cannot be validated until then: posts starts empty, so
   // an empty list must not read as "parent missing" before the fetch, nor as
   // "parent exists" for signing. Submit of a restored reply blocks meanwhile.
-  const [postsLoaded, setPostsLoaded] = useState(false);
-  // Set when the initial comments fetch fails (503 / network rejection / bad
-  // payload). postsLoaded stays false so a restored reply keeps pending and
-  // the draft is never silently turned top-level; the composer shows Retry.
-  const [loadError, setLoadError] = useState<string | null>(null);
+  // loadError arms the Retry button; postsLoaded stays false on failure so a
+  // restored reply keeps pending and the draft is never silently top-level.
+  const [{ postsLoaded, loadError }, setLoadState] = useState(initialPostsLoadState);
   // Draft restores async after hydration so server and client render the same empty composer first.
   // The loaded value is always assigned (even when empty) so text typed for one
   // token can never leak into — and be submitted from — another token's composer.
@@ -74,8 +72,7 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
       setReplyTo(d.parentId);
       setShownCount(COMMENTS_PAGE);
       setPosts([]);
-      setPostsLoaded(false);
-      setLoadError(null);
+      setLoadState(initialPostsLoadState);
       setErr(null);
     }, 0);
     return () => clearTimeout(t);
@@ -100,24 +97,23 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
       if (!res.ok) {
         // Failure, not proof of anything: keep postsLoaded false so a restored
         // reply stays pending (submit blocks) and the draft keeps its destination.
-        setLoadError(nextPostsLoadState({ postsLoaded: false, loadError: null }, { kind: "http-error", status: res.status }).loadError);
+        setLoadState((prev) => nextPostsLoadState(prev, { kind: "http-error", status: res.status }));
         return;
       }
       const d = (await res.json()) as { posts: PostRow[]; muted: boolean };
       if (!Array.isArray(d.posts)) {
         if (ignored()) return;
-        setLoadError(nextPostsLoadState({ postsLoaded: false, loadError: null }, { kind: "invalid" }).loadError);
+        setLoadState((prev) => nextPostsLoadState(prev, { kind: "invalid" }));
         return;
       }
       if (ignored()) return;
       setPosts(d.posts);
       setMuted(d.muted);
       setNow(nowMs());
-      setPostsLoaded(true);
-      setLoadError(null);
+      setLoadState((prev) => nextPostsLoadState(prev, { kind: "ok" }));
     } catch {
       if (ignored()) return;
-      setLoadError(nextPostsLoadState({ postsLoaded: false, loadError: null }, { kind: "network-error" }).loadError);
+      setLoadState((prev) => nextPostsLoadState(prev, { kind: "network-error" }));
     }
   }, [chain, token]);
 
@@ -149,7 +145,7 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
   // an unvalidated parent. After load the truncated posts window (latest 100) is
   // not authoritative — a missing id there does not mean the parent is gone, so
   // we preserve the target and let the server decide (no silent top-level fallback).
-  const { target: effectiveReplyTo, pending: validationPending, missing: replyMissing } = resolveReplyTarget(replyTo, posts, postsLoaded);
+  const { target: effectiveReplyTo, pending: validationPending } = resolveReplyTarget(replyTo, postsLoaded);
 
   async function submit() {
     if (!address) return;
@@ -159,7 +155,7 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
       return;
     }
     // Re-resolve here: posts may have changed since the last render.
-    const resolved = resolveReplyTarget(replyTo, posts, postsLoaded);
+    const resolved = resolveReplyTarget(replyTo, postsLoaded);
     if (resolved.pending) {
       setErr("Loading comments — please try again in a moment.");
       return;
@@ -263,7 +259,7 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
                 {loadError ? (
                   <p className="text-[11px] text-down-ink" role="alert">
                     {loadError}{" "}
-                    <button type="button" className="underline hover:text-ink" onClick={() => { setLoadError(null); void load(); }}>
+                    <button type="button" className="underline hover:text-ink" onClick={() => { setLoadState((prev) => ({ ...prev, loadError: null })); void load(); }}>
                       Try again
                     </button>
                   </p>
@@ -276,10 +272,6 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
                   cancel
                 </button>
               </p>
-            ) : replyMissing ? (
-              <p className="text-[11px] text-muted" role="status">
-                The comment you were replying to is gone — posting as a top-level comment.
-              </p>
             ) : null}
             <textarea
               value={body}
@@ -294,11 +286,14 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
               className="w-full rounded-xl bg-card border border-line-strong focus:border-brand focus:ring-4 focus:ring-brand/10 outline-none px-3 py-2 text-sm text-ink placeholder:text-faint min-h-16 resize-y"
             />
             <div className="flex items-center justify-between gap-3">
-              <span id={`comment-count-${chain}`} aria-live="polite" className="text-[11px] text-muted font-mono tnum">{POST_MAX - body.length}</span>
+              <span id={`comment-count-${chain}`} className="text-[11px] text-muted font-mono tnum">{POST_MAX - body.length}</span>
               <button type="button" onClick={() => void submit()} disabled={busy || !body.trim() || validationPending} className={btn.primarySm}>
                 {busy ? "Sign in wallet…" : validationPending ? "Checking…" : effectiveReplyTo !== null ? "Reply" : "Post"}
               </button>
             </div>
+            {POST_MAX - body.length <= 50 ? (
+              <p className="sr-only" role="status">{POST_MAX - body.length} characters remaining</p>
+            ) : null}
             {err ? <p className="text-xs text-down-ink" role="alert">{err}</p> : null}
           </div>
         )}
@@ -310,7 +305,7 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
           const thread = repliesById.get(p.id) ?? [];
           return (
           <li key={p.id} className="px-4 py-3">
-            <PostItem p={p} now={now} canReply={isConnected && !muted} onReply={() => { setReplyTo(p.id); saveDraft(chain, token, body, p.id); }} onReport={address && p.wallet !== address.toLowerCase() ? (r) => void report(p, r) : undefined} />
+            <PostItem p={p} now={now} canReply={isConnected && !muted} onReply={() => { setReplyTo(p.id); if (body) saveDraft(chain, token, body, p.id); }} onReport={address && p.wallet !== address.toLowerCase() ? (r) => void report(p, r) : undefined} />
             {thread.length ? (
               <ul className="mt-2 ml-6 pl-3 border-l border-line space-y-2">
                 {thread.map((r) => (
@@ -329,10 +324,10 @@ export default function TokenComments({ chain, token, symbol, launcher, embedded
           <button
             type="button"
             onClick={() => setShownCount((n) => n + COMMENTS_PAGE)}
-            aria-label={`Show more comments, ${remaining} remaining`}
+            aria-label={`Show more comments, ${remaining} remaining, showing ${visibleTop.length} of ${top.length}`}
             className="min-h-10 rounded-xl border border-line-strong px-4 text-sm font-medium text-ink hover:bg-card"
           >
-            Show more comments ({visibleTop.length} of {top.length})
+            Show more
           </button>
           <p className="mt-1 text-[11px] text-muted" role="status">Showing {visibleTop.length} of {top.length} comments</p>
         </div>
diff --git a/app/src/lib/launchpad/post-threads.test.ts b/app/src/lib/launchpad/post-threads.test.ts
index 533f364a..7a517aaf 100644
--- a/app/src/lib/launchpad/post-threads.test.ts
+++ b/app/src/lib/launchpad/post-threads.test.ts
@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { COMMENTS_PAGE, clearDraft, draftKey, groupReplies, initialPostsLoadState, loadCommentDraft, loadDraft, nextPostsLoadState, resolveReplyTarget, saveDraft, shouldIgnoreLoad, visibleTopIds } from "./post-threads.ts";
+import { COMMENTS_PAGE, clearDraft, draftKey, groupReplies, initialPostsLoadState, loadCommentDraft, nextPostsLoadState, resolveReplyTarget, saveDraft, shouldIgnoreLoad, visibleTopIds } from "./post-threads.ts";
 import type { PostRow } from "./postsServer.ts";
 
 const post = (id: number, parent_id: number | null): PostRow => ({ id, chain: "base", token: "0xtoken", wallet: "0xwallet", parent_id, body: `body ${id}`, tag: null, created_at: "2026-01-01T00:00:00.000Z", reports: 0, hidden: false });
@@ -31,10 +31,10 @@ test("visibleTopIds paginates the top level", () => {
 test("draft key is per token and lowercase; node loads empty and saves are no-ops", () => {
   assert.equal(draftKey("base", "0xABC"), "ol:comment-draft:base:0xabc");
   assert.notEqual(draftKey("base", "0xabc"), draftKey("robinhood", "0xabc"));
-  assert.equal(loadDraft("base", "0xabc"), "");
+  assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null });
   saveDraft("base", "0xabc", "hello");
   clearDraft("base", "0xabc");
-  assert.equal(loadDraft("base", "0xabc"), "", "no localStorage in node: always empty, never throws");
+  assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null }, "no localStorage in node: always empty, never throws");
 });
 
 function withMemoryStorage(): Map<string, string> {
@@ -53,12 +53,11 @@ function withoutStorage(): void {
   delete g.localStorage;
 }
 
-test("draft restores both a top-level draft and a reply draft (PR #31)", () => {
+test("draft restores both a top-level draft and a reply draft", () => {
   const store = withMemoryStorage();
   try {
     saveDraft("base", "0xabc", "top-level hello");
     assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "top-level hello", parentId: null });
-    assert.equal(loadDraft("base", "0xabc"), "top-level hello");
 
     saveDraft("base", "0xabc", "reply hello", 42);
     assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "reply hello", parentId: 42 });
@@ -71,43 +70,44 @@ test("draft restores both a top-level draft and a reply draft (PR #31)", () => {
   }
 });
 
-test("draft understands legacy plain-text drafts and rejects bad parent ids", () => {
+test("draft ignores non-JSON content and rejects bad parent ids; empty body stores nothing", () => {
   const store = withMemoryStorage();
   try {
     store.set(draftKey("base", "0xabc"), "legacy hello");
-    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "legacy hello", parentId: null });
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null });
 
     store.set(draftKey("base", "0xabc"), JSON.stringify({ body: "x", parentId: -7 }));
     assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "x", parentId: null });
 
     store.set(draftKey("base", "0xabc"), JSON.stringify({ body: "x", parentId: "42" }));
     assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "x", parentId: null });
+
+    // Clicking Reply with an empty composer must not leave "Replying to #x" behind.
+    saveDraft("base", "0xabc", "", 42);
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null });
+    assert.equal(store.has(draftKey("base", "0xabc")), false);
+
+    store.set(draftKey("base", "0xabc"), JSON.stringify({ body: "", parentId: 42 }));
+    assert.deepEqual(loadCommentDraft("base", "0xabc"), { body: "", parentId: null });
   } finally {
     withoutStorage();
   }
 });
 
-test("resolveReplyTarget blocks before first load and preserves reply when posts window is truncated (PR #31)", () => {
-  assert.deepEqual(resolveReplyTarget(null, [], false), { target: null, pending: false, missing: false }, "top-level never blocks");
-  assert.deepEqual(resolveReplyTarget(null, [], true), { target: null, pending: false, missing: false });
-  assert.deepEqual(resolveReplyTarget(42, [], false), { target: 42, pending: true, missing: false }, "restored reply is pending before validation, never signed");
+test("resolveReplyTarget blocks before first load and preserves reply after load", () => {
+  assert.deepEqual(resolveReplyTarget(null, false), { target: null, pending: false }, "top-level never blocks");
+  assert.deepEqual(resolveReplyTarget(null, true), { target: null, pending: false });
+  assert.deepEqual(resolveReplyTarget(42, false), { target: 42, pending: true }, "restored reply is pending before validation, never signed");
   // After a successful load the posts window is truncated (latest 100). Absence there is not proof the parent was deleted.
-  assert.deepEqual(resolveReplyTarget(42, [], true), { target: 42, pending: false, missing: false }, "empty window is not proof parent is gone — preserve");
-  assert.deepEqual(resolveReplyTarget(42, [{ id: 42 }], true), { target: 42, pending: false, missing: false }, "present parent stays a reply");
-  assert.deepEqual(resolveReplyTarget(42, [{ id: 7 }], true), { target: 42, pending: false, missing: false }, "parent not in truncated window preserves target");
+  assert.deepEqual(resolveReplyTarget(42, true), { target: 42, pending: false }, "preserve after load; server rejects if truly gone");
 });
 
-test("resolveReplyTarget preserves valid parent outside returned window (PR #31 regression)", () => {
-  // Saved reply to 100, response contains only 200..101 — parent still exists but is outside the window.
-  const window = Array.from({ length: 100 }, (_, i) => ({ id: 200 - i }));
-  assert.equal(window.some((p) => p.id === 100), false, "100 is outside the latest-100 window");
-  assert.deepEqual(resolveReplyTarget(100, window, true), { target: 100, pending: false, missing: false }, "valid parent outside window must not become top-level");
-  // Before validation (postsLoaded false) the same draft stays pending even on failure (503 / network rejection) — no silent fallback
-  assert.deepEqual(resolveReplyTarget(100, [], false), { target: 100, pending: true, missing: false }, "failed/no-load keeps pending so draft isn't lost");
-  assert.deepEqual(resolveReplyTarget(100, window, false), { target: 100, pending: true, missing: false });
+test("resolveReplyTarget preserves reply when validation has not completed", () => {
+  // Before validation (postsLoaded false) the draft stays pending even on failure (503 / network rejection) — no silent fallback
+  assert.deepEqual(resolveReplyTarget(100, false), { target: 100, pending: true }, "failed/no-load keeps pending so draft isn't lost");
 });
 
-test("shouldIgnoreLoad drops stale/aborted responses so token A cannot overwrite token B (PR #31)", () => {
+test("shouldIgnoreLoad drops stale/aborted responses so token A cannot overwrite token B", () => {
   // Token A starts load id 1; switching to B bumps generation to 2 and aborts A.
   assert.equal(shouldIgnoreLoad(1, 1, false), false, "current generation, live request: apply");
   assert.equal(shouldIgnoreLoad(1, 2, false), true, "older request resolving after token switch: ignore");
@@ -116,16 +116,16 @@ test("shouldIgnoreLoad drops stale/aborted responses so token A cannot overwrite
   assert.equal(shouldIgnoreLoad(2, 2, false), false, "newer request for the current token: apply");
 });
 
-test("nextPostsLoadState keeps a restored reply pending with Retry after 503/network failure (PR #31)", () => {
+test("nextPostsLoadState keeps a restored reply pending with Retry after 503/network failure", () => {
   // Initial 503: postsLoaded stays false (reply stays pending, submit blocks), error arms Retry.
   const after503 = nextPostsLoadState(initialPostsLoadState, { kind: "http-error", status: 503 });
   assert.deepEqual(after503, { postsLoaded: false, loadError: "Could not load comments (503)." });
-  assert.deepEqual(resolveReplyTarget(42, [], after503.postsLoaded), { target: 42, pending: true, missing: false }, "draft destination preserved, still pending — never silently top-level");
+  assert.deepEqual(resolveReplyTarget(42, after503.postsLoaded), { target: 42, pending: true }, "draft destination preserved, still pending — never silently top-level");
 
   // Network rejection: same shape, connection hint.
   const afterNet = nextPostsLoadState(initialPostsLoadState, { kind: "network-error" });
   assert.deepEqual(afterNet, { postsLoaded: false, loadError: "Could not load comments. Check your connection." });
-  assert.deepEqual(resolveReplyTarget(42, [], afterNet.postsLoaded), { target: 42, pending: true, missing: false });
+  assert.deepEqual(resolveReplyTarget(42, afterNet.postsLoaded), { target: 42, pending: true });
 
   // Retry succeeding clears the error and unblocks validation.
   const recovered = nextPostsLoadState(after503, { kind: "ok" });
diff --git a/app/src/lib/launchpad/post-threads.ts b/app/src/lib/launchpad/post-threads.ts
index d772b14c..02706c3e 100644
--- a/app/src/lib/launchpad/post-threads.ts
+++ b/app/src/lib/launchpad/post-threads.ts
@@ -43,7 +43,7 @@ function cleanParentId(v: unknown): number | null {
   return typeof v === "number" && Number.isInteger(v) && v > 0 ? v : null;
 }
 
-/** Load the full draft (body + reply target). Understands the new JSON shape and legacy plain-text drafts. */
+/** Load the full draft (body + reply target). Only the JSON shape is read; anything else is treated as no draft. */
 export function loadCommentDraft(chain: string, token: string): CommentDraft {
   try {
     if (typeof localStorage === "undefined") return { body: "", parentId: null };
@@ -52,27 +52,29 @@ export function loadCommentDraft(chain: string, token: string): CommentDraft {
     try {
       const parsed = JSON.parse(raw) as { body?: unknown; parentId?: unknown };
       if (parsed && typeof parsed === "object" && typeof parsed.body === "string") {
+        if (!parsed.body) return { body: "", parentId: null };
         return { body: parsed.body, parentId: cleanParentId(parsed.parentId) };
       }
     } catch {
-      /* legacy plain-text draft falls through */
+      /* not a draft we wrote: ignore */
     }
-    return { body: raw, parentId: null };
+    return { body: "", parentId: null };
   } catch {
     return { body: "", parentId: null };
   }
 }
 
-export function loadDraft(chain: string, token: string): string {
-  return loadCommentDraft(chain, token).body;
-}
-
 export function saveDraft(chain: string, token: string, body: string, parentId: number | null = null): void {
   try {
     if (typeof localStorage === "undefined") return;
+    // An empty body stores nothing: clicking Reply alone must not leave a
+    // "Replying to #x" draft behind after a reload.
+    if (!body) {
+      localStorage.removeItem(draftKey(chain, token));
+      return;
+    }
     const pid = cleanParentId(parentId);
-    if (!body && pid === null) localStorage.removeItem(draftKey(chain, token));
-    else localStorage.setItem(draftKey(chain, token), JSON.stringify({ body: body.slice(0, 2000), parentId: pid }));
+    localStorage.setItem(draftKey(chain, token), JSON.stringify({ body: body.slice(0, 2000), parentId: pid }));
   } catch {
     /* storage blocked: the in-memory textarea state is what survives */
   }
@@ -88,7 +90,7 @@ export function clearDraft(chain: string, token: string): void {
 }
 
 /**
- * Resolve a restored reply target against the loaded posts (PR #31).
+ * Resolve a restored reply target against the loaded posts.
  *
  * Draft restoration and the initial posts fetch race: posts starts empty, so
  * an empty list must not read as "parent missing" before the fetch, nor as
@@ -103,19 +105,18 @@ export function clearDraft(chain: string, token: string): void {
  */
 export function resolveReplyTarget(
   replyTo: number | null,
-  posts: readonly { id: number }[],
   postsLoaded: boolean,
-): { target: number | null; pending: boolean; missing: boolean } {
-  if (replyTo === null) return { target: null, pending: false, missing: false };
-  if (!postsLoaded) return { target: replyTo, pending: true, missing: false };
+): { target: number | null; pending: boolean } {
+  if (replyTo === null) return { target: null, pending: false };
+  if (!postsLoaded) return { target: replyTo, pending: true };
   // Window is truncated: missing from the latest 100 does not mean deleted.
   // Preserve the target; server will return 404 if truly gone and the UI will
   // surface that error instead of silently changing the destination.
-  return { target: replyTo, pending: false, missing: false };
+  return { target: replyTo, pending: false };
 }
 
 /**
- * Stale-load guard for TokenComments (PR #31).
+ * Stale-load guard for TokenComments.
  *
  * A fetch for token A resolving after the switch to token B must not touch
  * B's posts or postsLoaded. The component bumps a generation counter on every
@@ -141,7 +142,7 @@ export type PostsLoadOutcome =
   | { kind: "ignored" };
 
 /**
- * Reducer for the initial comments fetch (PR #31).
+ * Reducer for the initial comments fetch.
  *
  * Failure paths preserve the draft and its reply destination: postsLoaded
  * stays false (restored reply keeps pending, submit keeps blocking) and a