@@ -2110,6 +2110,18 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
             }
           }
         }
+        // objectui#12144: each comment's reply count is its children in the
+        // rows this read returned. `sys_comment` stores no count: its object
+        // definition says to count `parent_id` children at read time. With
+        // threading on, the timeline shows a comment's replies only under a
+        // `replyCount` above zero, so without this a stored reply was shown
+        // nowhere. Counted the way the timeline groups replies: by the row's
+        // `parent_id`, when it has one. A reply whose parent is not among
+        // these rows counts toward no item here.
+        const replyCounts = new Map<unknown, number>();
+        for (const c of res.data as Array<{ parent_id?: unknown }>) {
+          if (c.parent_id) replyCounts.set(c.parent_id, (replyCounts.get(c.parent_id) ?? 0) + 1);
+        }
         const mapped: FeedItem[] = res.data.map((c: any) => ({
           id: c.id,
           type: 'comment' as const,
@@ -2119,6 +2131,7 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
           createdAt: c.created_at,
           updatedAt: c.updated_at,
           parentId: c.parent_id ?? undefined,
+          replyCount: replyCounts.get(c.id),
           reactions:
             reactionStore === 'records'
               ? toReactions(records?.stored.get(String(c.id)))
 
@@ -198,6 +198,22 @@ function canStoreReaction(item: FeedItem): boolean {
   return item.type === 'comment';
 }
 
+/**
+ * Whether a feed row can take a reply (objectui#12144).
+ *
+ * A reply is a `sys_comment` row whose `parent_id` names the comment it
+ * answers, so only a `comment` row offers the reply input. A row read from
+ * `sys_activity` offers none: a reply there would store a comment whose parent
+ * is an activity, which no read shows under it. Same reasoning as
+ * {@link canStoreReaction}.
+ */
+function canTakeReply(item: FeedItem): boolean {
+  return item.type === 'comment';
+}
+
+/** The reply list a row shows while its `replyCount` is zero (objectui#12144). */
+const NO_REPLIES: FeedItem[] = [];
+
 function filterItems(items: FeedItem[], mode: FeedFilterMode): FeedItem[] {
   switch (mode) {
     case 'comments_only':
@@ -532,7 +548,14 @@ export const RecordActivityTimeline: React.FC<RecordActivityTimelineProps> = ({
                 const Icon = FEED_TYPE_ICONS[item.type] || Zap;
                 const colorClass =
                   FEED_TYPE_COLORS[item.type] || 'bg-gray-100 text-gray-600';
-                const replies = repliesByParent.get(item.id) ?? [];
+                // Threading (objectui#12144). The reply LIST shows only under a
+                // `replyCount` above zero, the one threading gate: the host that
+                // read the rows sets it. The reply INPUT does not wait for a
+                // first reply, so a comment with none offers it wherever the
+                // host hands over `onAddReply`.
+                const replies =
+                  (item.replyCount ?? 0) > 0 ? (repliesByParent.get(item.id) ?? NO_REPLIES) : NO_REPLIES;
+                const offersReply = !!onAddReply && canTakeReply(item);
                 // Undefined on a row that cannot store a reaction: no Add
                 // reaction button, and its chips render disabled (objectui#11035).
                 const toggleReaction =
@@ -631,12 +654,12 @@ export const RecordActivityTimeline: React.FC<RecordActivityTimelineProps> = ({
                     </div>
 
                     {/* Threading */}
-                    {enableThreading && (item.replyCount ?? 0) > 0 && (
+                    {enableThreading && (replies.length > 0 || offersReply) && (
                       <ThreadedReplies
                         parentItem={item}
                         replies={replies}
                         onAddReply={onAddReply}
-                        showReplyInput={!!onAddReply}
+                        showReplyInput={offersReply}
                       />
                     )}
                   </div>
 
@@ -0,0 +1,126 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * The reply input does not wait for a first reply, and the reply list keeps its
+ * one `replyCount` gate (objectui#12144).
+ *
+ * With threading on, the timeline drew `ThreadedReplies`, the only place the
+ * reply input renders, only under an item whose `replyCount` was above zero.
+ * Nothing set it on a comment with no replies, so such a comment never offered
+ * the input and its first reply could not be posted. Now:
+ *
+ *  - the INPUT is offered on every comment row the host hands `onAddReply` for,
+ *    replies or not, and on no other row (a reply is a `sys_comment` whose
+ *    parent is a comment);
+ *  - the LIST still shows only under a `replyCount` above zero, so whether a
+ *    comment's replies show never depends on whether the caller may post one.
+ *
+ * The record page's read is what sets `replyCount`; that half is pinned through
+ * the page in `@object-ui/app-shell`
+ * (`RecordDetailView.replyCountOnRead-12144.test.tsx`). This file pins the
+ * timeline's render condition alone.
+ *
+ * Real subjects: `RecordActivityTimeline` and `ThreadedReplies`; the activity
+ * row is built by `activityRowToFeedItem`, the reading the record page merges
+ * `sys_activity` rows through.
+ */
+
+import * as React from 'react';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, cleanup, within } from '@testing-library/react';
+import type { FeedItem } from '@object-ui/types';
+import { RecordActivityTimeline } from '../RecordActivityTimeline';
+import { activityRowToFeedItem } from '../renderers/recordActivityFeed';
+import { DETAIL_DEFAULT_TRANSLATIONS } from '../useDetailTranslation';
+
+const REPLY_PLACEHOLDER = DETAIL_DEFAULT_TRANSLATIONS['detail.replyPlaceholder'];
+const PARENT_BODY = 'Parent comment';
+const REPLY_BODY = 'A reply to the parent';
+const ACTIVITY_SUMMARY = 'Stage changed';
+
+const PARENT: FeedItem = {
+  id: 'c1',
+  type: 'comment',
+  actor: 'Grace',
+  body: PARENT_BODY,
+  createdAt: '2026-10-01T08:00:00.000Z',
+};
+
+const REPLY: FeedItem = {
+  id: 'c2',
+  type: 'comment',
+  actor: 'Ada',
+  body: REPLY_BODY,
+  createdAt: '2026-10-01T09:00:00.000Z',
+  parentId: 'c1',
+};
+
+const ACTIVITY = activityRowToFeedItem(
+  { id: 'a1', type: 'updated', summary: ACTIVITY_SUMMARY, actor_name: 'Ada', timestamp: '2026-10-01T07:00:00.000Z' },
+  'System',
+) as FeedItem;
+
+function mount(items: FeedItem[], { threading = true, onAddReply }: { threading?: boolean; onAddReply?: () => void } = {}) {
+  render(<RecordActivityTimeline items={items} config={{ enableThreading: threading }} onAddReply={onAddReply} />);
+}
+
+/** The feed row a body sits in: the keyed root element holding the row and its replies. */
+function rootRowOf(body: string): HTMLElement {
+  const rows = screen.getByText(body).closest('.space-y-4')!.children;
+  const row = Array.from(rows).find((r) => r.textContent?.includes(body));
+  if (!row) throw new Error(`no feed row holds ${JSON.stringify(body)}`);
+  return row as HTMLElement;
+}
+
+const replyInputs = () => screen.queryAllByPlaceholderText(REPLY_PLACEHOLDER);
+const replyToggles = () => screen.queryAllByRole('button', { name: /\d+ repl/ });
+
+afterEach(() => {
+  cleanup();
+});
+
+describe('the reply input does not wait for a first reply (objectui#12144)', () => {
+  it('a comment with no replies offers it when the host hands over onAddReply', () => {
+    mount([PARENT], { onAddReply: vi.fn() });
+    expect(within(rootRowOf(PARENT_BODY)).queryByPlaceholderText(REPLY_PLACEHOLDER)).not.toBeNull();
+    expect(replyToggles()).toHaveLength(0);
+  });
+
+  it('CONTROL: without onAddReply the same comment offers none', () => {
+    mount([PARENT]);
+    expect(replyInputs()).toHaveLength(0);
+  });
+
+  it('a row that is not a comment offers none, beside a comment that does', () => {
+    expect(ACTIVITY.type).not.toBe('comment');
+    mount([ACTIVITY, PARENT], { onAddReply: vi.fn() });
+    expect(within(rootRowOf(ACTIVITY_SUMMARY)).queryByPlaceholderText(REPLY_PLACEHOLDER)).toBeNull();
+    expect(replyInputs()).toHaveLength(1);
+  });
+
+  it('CONTROL: with threading off no row offers it', () => {
+    mount([PARENT], { threading: false, onAddReply: vi.fn() });
+    expect(replyInputs()).toHaveLength(0);
+  });
+});
+
+describe("the reply list keeps its one replyCount gate (objectui#12144)", () => {
+  it('replies the host handed over without a replyCount stay hidden, whether or not the input is offered', () => {
+    mount([PARENT, REPLY], { onAddReply: vi.fn() });
+    expect(replyToggles()).toHaveLength(0);
+    expect(screen.queryByText(REPLY_BODY)).toBeNull();
+    expect(replyInputs()).toHaveLength(1);
+  });
+
+  it('with a replyCount above zero the list shows, and it shows without the input too', () => {
+    mount([{ ...PARENT, replyCount: 1 }, REPLY]);
+    expect(replyInputs()).toHaveLength(0);
+    expect(within(rootRowOf(PARENT_BODY)).getAllByRole('button', { name: /1 reply/ })).toHaveLength(1);
+  });
+});