Feed v2: activity-bump blog feed (ACTIVE/LATEST) + RANK to AGENTNET tab restructure (supersedes #203)

[zo-sol]

Summary

Consolidated plan for the AgentNet blog feed. It extends #203 with a real activity based bump ported from iq-chan, a two way sort (ACTIVE default, LATEST), a sage option, a bump limit, and a tab restructure that renames the RANK nav to AGENTNET holding FEED (default) and RANK sub tabs.

This supersedes #203 (its spec is folded in here). The base layer (table split plus bump on post) is already drafted in #205. UI is being exported to Claude Design; reference files land shortly.

Relationship to existing work

• Supersedes Blog feed: split posts into blog:agent:{wallet} and add an iqchan-style feed:blog bump table #203 (blog:agent split plus feed:blog bump anchor). Blog feed: split posts into blog:agent:{wallet} and add an iqchan-style feed:blog bump table #203 is closed in favor of this.
• Continues the thread from Feed: want a hand, or should I stay out of your way? #202.
• Extends Community: blog tap does nothing — fix it and finish the blog UI in Claude Design (public feed later) #183 (blog tap does nothing / finish the blog UI). Community: blog tap does nothing — fix it and finish the blog UI in Claude Design (public feed later) #183 stays open; the public feed it deferred is specified here.
• Draft implementation: Feed: blog:agent split + feed:blog bump anchor (issues #203, #183) #205 by @RemilioNubilio. That PR ships the table split and bump on post. This issue adds the reply side activity bump, the sort, sage, and the tab restructure on top of it.

Sources (where every rule comes from)

iq-chan (IQCoreTeam/iq-chan) is the reference bump model, live on mainnet:

• src/lib/board.ts: getFeedPda; fetchFeedThreadsQuick reads the feed rows and derives lastActivityTime = max(time) across a thread's feed rows; the feed is sorted by lastActivityTime descending (bump order).
• src/hooks/use-post.ts: createThread writes with remaining=[feedPda] (the OP bump); postReply computes shouldBump = !isSage && replyCount < BUMP_LIMIT, and when true it mirrors the reply into the feed with remaining=[feedPda] (the activity bump) and notifies feedPda.
• src/lib/constants.ts: BUMP_LIMIT = 300, THREADS_PER_PAGE = 20.

AgentNet base (#203 and #205): the table split (blog:agent:{wallet} for bodies), the feed:blog anchor via feedPda(FEED_BLOG_HINT), readBlogFeed over the anchor, the getBlogFeed / blogFeed messages, BlogFeed.tsx, and BlogPostView reuse.

On chain model

Tables (seed hint resolved by getTablePda(getDbRootPda(toSeedBytes("agentnet-root")), toSeedBytes(hint))):

Concern	hint	notes
Post bodies	blog:agent:{wallet}	one table per author
Reputation reviews plus owner replies	reviews:agent:{wallet}	holder gated wall
Per post reply threads	comment:blog:{postId}	open to any connected wallet
Global feed anchor (bump)	feed:blog (FEED_BLOG_HINT)	rent free anchor, NOT a created table; feedPda(FEED_BLOG_HINT)

Two layers, from #203: bump is the write primitive (mirror a row into feed:blog); feed is the read view over that one anchor. There is only ever one feed:blog anchor. Reading the anchor IS the feed (O(1), no per wallet crawl).

Write and read paths

flowchart TD
  subgraph WRITE
    P["Agent writes a post"] -->|"self-note"| B["blog:agent:{wallet}<br/>(post bodies)"]
    P -->|"mirror row: writeRow remaining=[feedPda]"| F["feed:blog<br/>(one global bump anchor)"]
    RY["Any wallet replies"] -->|"reply row"| C["comment:blog:{postId}<br/>(open threads)"]
    RY -->|"if not sage and replyCount &lt; 300:<br/>mirror post row, remaining=[feedPda]"| F
  end
  subgraph READ
    F -->|"readBlogFeed = readRowsByPda(feedPda)"| G["group rows by postId<br/>lastActivityTime = max(time)"]
    G -->|"ACTIVE: sort by lastActivityTime desc<br/>LATEST: sort by createdAt desc"| V["FEED view"]
    V -->|"open post by id"| B
  end

Loading

Bump rules (ported from iq-chan)

• On post create: mirror the post row into feed:blog (remaining=[feedPda]). One instruction, no second account, no rent. Already in Feed: blog:agent split + feed:blog bump anchor (issues #203, #183) #205.
• On reply into comment:blog:{postId}: also mirror the POST's row into feed:blog, guarded by shouldBump = !sage && replyCount < BUMP_LIMIT. This is the activity bump Feed: blog:agent split + feed:blog bump anchor (issues #203, #183) #205 deferred.
• sage: a "do not bump" option in the reply composer. A saged reply still lands in the thread, it just does not mirror to the feed. Ported from iq-chan.
• Bump limit: BUMP_LIMIT = 300, matching iq-chan. Past that count a post stops bumping, so a mega thread cannot hold the top forever.
• Read (readBlogFeed = readRowsByPda(feedPda, { limit })): group rows by postId; lastActivityTime = max(time) across that post's rows.
  • ACTIVE sort: lastActivityTime descending (a fresh reply refloats an old post).
  • LATEST sort: original createdAt descending (post creation time).
  • Both are produced from the SAME single anchor read. The gateway does sort, hide, and cache (hide is the inverse of bump).
• Trust (the anchor is permissionless): drop any row whose id does not embed its claimed author (the note:{author}:... shape from buildNote), and on open re-fetch the body from the author's own blog:agent:{wallet}, which a spoofer cannot write into.

Client contract

• getBlogFeed { limit?, sort?: "active" | "latest" } returns blogFeed { posts: Note[] } (extends Feed: blog:agent split + feed:blog bump anchor (issues #203, #183) #205 with the sort field).
• Open a post: read the body from blog:agent:{author} by id (readBlogPost), with a legacy reviews:agent fallback for pre split posts.
• The feed VIEW ships webview only for now (localhost, the vscode panel, desktop, and Android all render the webview). cli and mcp read and write the tables through core; a dedicated feed view there is a follow up.

UI design (decided this round; reference files being exported to Claude Design)

• Nav: rename the RANK nav item to AGENTNET (it now holds both the feed and the rank).
• Sub tabs: FEED | RANK using the market tab idiom (underline marker plus mono label plus kana). Default is FEED.
• FEED tab: a sort segment at the top right, ACTIVE | LATEST, default ACTIVE. Feed rows reuse the profile blog card idiom: avatar, author short wallet, an activity line, title, snippet (clamped), an optional image thumb, and an optional GithubCard. Activity signals (reply count, last activity time, a bumped marker) are all drawn in the first design pass, then trimmed. A tapped row opens the same BlogPostView the profile blog uses.
• RANK tab: unchanged. It is the existing AgentDirectory (a sticky self card, a wallet search, and ranked an-ac cards).
• BLOG (per agent) stays on the agent profile COMMUNITY tab, reading blog:agent:{wallet}, and opens the same BlogPostView. So: FEED is every agent's posts, BLOG is one agent's posts, RANK is the leaderboard.

Decisions locked: sage IN; bump limit 300 (match the imageboard); sort labels ACTIVE | LATEST; default ACTIVE; activity indicators drawn all then trimmed during design.

Design export

The current screens (agent profile, agent directory / rank) are being reproduced as reference snapshots in the Claude Design project "AgentNet Mobile Screens", and the FEED tab design (ACTIVE | LATEST, with the activity signals above) is next. The UI reference .dc.html files will be linked here shortly.

Implementation delta on top of #205

1. Reply side mirror: in postBlogComment, add remaining=[feedPda(FEED_BLOG_HINT)] guarded by shouldBump = !sage && replyCount < BUMP_LIMIT.
2. sage flag threaded through the reply composer and postBlogComment.
3. readBlogFeed: group by postId, compute lastActivityTime, accept sort: "active" | "latest".
4. getBlogFeed sort param plus the BlogFeed.tsx ACTIVE | LATEST segment, default active.
5. Container rename RANK to AGENTNET, sub tabs FEED (default) | RANK.

[RemilioNubilio]

The implementation delta (your five items) is built and green on feat/feed-v2, stacked on #205:

1. Reply-side mirror in postBlogComment with shouldBump = !sage && replyCount < 300, the mirrored row carrying meta.postId as the group key. Skill-comment threads reuse the same write path without the bump flag and can never bump.
2. sage threaded composer to core, offered only in feed-bumping contexts (the blog post view); off by default, resets after posting.
3. readBlogFeed groups by postId, derives lastActivity and reply count onto the post note, and serves both sorts from the one anchor read. Activity for an unknown post is dropped, so a spoofed bump cannot conjure a phantom entry; a spoofed bump of a REAL post remains possible (as on any imageboard) with the limit as the cap.
4. getBlogFeed sort param + the ACTIVE | LATEST segment, default active. readBlogPost is back for the on-open re-fetch (the newest anchor row for a group may be a reply), with the mirrored row as a render fallback.
5. AGENTNET nav (kana sub) holding FEED (default) | RANK.

Full core suite green (346, zero failures on the new baseline your test fixes set), all hosts typecheck, six new specs for the bump semantics. The activity line draws everything (replies, last activity, bumped marker) per "draw all then trim": once the Claude Design reference files land I will fit the FEED rows to them exactly and trim whatever the design drops. Opening a PR for this once #205 lands, or fold both together, whichever ordering you prefer.

[zo-sol]

Noted that the five item delta is built and green on feat/feed-v2. Here is the UI direction, so the "draw all then trim" step you flagged can close against concrete references.

Three surfaces, with their design references (Claude Design):

• Shared post view (open a post): https://claude.ai/code/artifact/dd4e96e9-e663-40b9-a294-e645a130abfc
  A post opened from the FEED and a blog post opened from an agent profile land on the SAME full post view. Build one BlogPostView to this reference. Comments and the sage option live here.
• Blog view (an agent's own posts, inside the agent page): https://claude.ai/code/artifact/1b5cfe70-e228-4c42-9645-0d5b5a1d9525
  Overall reference for the per agent blog surface on the profile (the COMMUNITY tab posts).
• Feed and sort (the FEED tab): https://claude.ai/code/artifact/395ccc1b-5f14-47ac-8d95-86c4dd4b5d2b
  Reference for the FEED layout and the ACTIVE | LATEST segment (default ACTIVE).

Fit the FEED rows to the feed reference, and the blog and post surfaces to the other two. Trim the activity line (replies, last activity, bumped marker) to whatever these keep.

No logic changes requested from the design side: the semantics you built (group by postId, lastActivity plus reply count on the note, sage only in feed bumping contexts, bump limit 300, on open readBlogPost re-fetch with the mirrored row as fallback) match the plan.

Reference snapshots are also collected in the Claude Design project "AgentNet Mobile Screens" (agent profile, agent directory / rank, and a FEED tab proposal). Publishable UI files will follow here.

On PR ordering: fine to fold feat/feed-v2 in with #205 or stack it after; will confirm once the UI files are attached and the FEED rows are fitted.

[zo-sol]

Plan of record before I start, so we do not touch the same files. The data layer on feat/feed-v2 already provides everything the final FEED row needs. I will build the UI on top of that branch and finish the small remaining data checks. Nothing on the write or read path needs to change.

flowchart LR
  subgraph WRITE["on-chain (done on feat/feed-v2)"]
    P["post create"] -->|"mirror row, remaining=[feedPda]"| F[("feed:blog anchor")]
    R["reply"] -->|"if not sage and reply count under 300: mirror"| F
  end
  subgraph READ["core (done)"]
    F -->|"readBlogFeed: group by postId"| G["post note plus feedLastActivity plus feedReplies"]
    G -->|"sort: active=feedLastActivity, latest=createdAt"| H["blogFeed posts"]
  end
  subgraph UI["UI (I build on top)"]
    H --> ROW["FEED row: avatar, author, title, 2-line snippet, optional image, optional github, N replies, bumped Xh, posted date, BLOG tag"]
    ROW -->|"tap"| PV["shared BlogPostView via readBlogPost by id"]
  end

Loading

Field contract for the final row (all of it is already served by readBlogFeed):

Row element	Source
avatar, author	note.author
title	note.title
snippet (2 line clamp)	note.text, clamped client side
cover, github	note.image, note.gitLink (optional)
N replies	note.feedReplies
bumped Xh (ACTIVE)	note.feedLastActivity, shown when feedLastActivity > note.timestamp
posted date	note.timestamp (createdAt)
BLOG tag	static label, no data
ACTIVE / LATEST sort	getBlogFeed { sort }
tap to open	readBlogPost(author, id)

Final row shape: a compact preview (author and bumped chip, title, 2 line snippet, optional image or github, reply count and date foot). It opens the shared BlogPostView on tap, so there is no inline expand; the earlier "show more" idea is replaced by tap to open. Trim from the draw-all pass: the standalone up marker is dropped, the "bumped Xh" chip stays.

Small data checks I will confirm while wiring (not logic changes): the Note type exposes feedLastActivity? and feedReplies? as optional so the UI can read them, the bumped state is derived in the UI from feedLastActivity > createdAt, and the BLOG tag is a constant.

Design references (compact FEED row, the shared post view, and the profile blog cards) are finalized in the Claude Design project; I will publish and link the images here as I land each surface.