Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

Merge batch 11-02 1102-r: #2586 (#2598)

0xken15b0b9e6925aa6
diff --git a/backend/integration/superTabActivity.test.ts b/backend/integration/superTabActivity.test.ts
index 466b9835a..050393880 100644
--- a/backend/integration/superTabActivity.test.ts
+++ b/backend/integration/superTabActivity.test.ts
@@ -15,7 +15,8 @@ import { migrateSwarm } from '../src/superTabs/migration/migrate.js'
import { SwarmReads } from '../src/superTabs/read/service.js'
import { HostReads } from '../src/superTabs/read/host.js'
import { buddyChatId, openSwarmBuddyChat } from '../src/superTabs/buddies.js'
-import { ACTIVITY_EXPIRY_MS, ACTIVITY_READS, resetActivityReads, sweepActivity } from '../src/superTabs/activity.js'
+import { ACTIVITY_EXPIRY_MS, ACTIVITY_READS, resetActivityReads, sweepActivity, writeReplyActivity } from '../src/superTabs/activity.js'
+import { SESSION_ENDED_KIND } from '../src/superTabs/buddySessions.js'
import { CHAT_SETTING_DEFAULT_KEEP_MS, sweepChatSettings } from '../src/superTabs/chatSettings.js'
import type { Command, SuperTabState } from '../src/superTabs/model.js'
import { writeLegacySwarm } from '../scripts/swarm-parts/legacy.js'
@@ -254,6 +255,86 @@ describe('Activity: read state and its digest', () => {
expect((await call('POST', `/api/super-tabs/${s.tabId}/activity/read`, 'team', { through: item.createdAt })).status).toBe(403)
})
+ const markThread = (tabId: string, conversationId: string, threadId: string, sequence: number, as: AuthUser = owner) =>
+ call('POST', `/api/super-tabs/${tabId}/conversations/${conversationId}/threads/${threadId}/read`, as, { sequence })
+ const markChat = (tabId: string, conversationId: string, sequence: number, as: AuthUser = owner) =>
+ call('POST', `/api/super-tabs/${tabId}/conversations/${conversationId}/read`, as, { sequence })
+ const sequenceOf = async (id: string) => (await db.superTabMessage.findUniqueOrThrow({ where: { id } })).sequence
+ const sendAlso = async (tabId: string, conversationId: string, text: string, as: AuthUser, replyTo: string) =>
+ (await run(tabId, { type: 'message.send', conversationId, text, replyTo, recipientIds: [], alsoSend: true }, as)).result.messageId as string
+
+ it('marks the reply rows of a thread read, on every device, when the thread is read past them', async () => {
+ const s = await scene()
+ const before = (await derived(s.tabId, owner)).activityDigest
+ const root = await send(s.tabId, s.web, 'Owner root')
+ const first = await send(s.tabId, s.web, 'Worker answers', owner, root, s.worker)
+ const second = await send(s.tabId, s.web, 'Worker answers again', owner, root, s.worker)
+ expect((await items(s.tabId)).map(i => i.read)).toEqual([false, false])
+ expect((await derived(s.tabId, owner)).activityDigest).not.toBe(before)
+ // A mark short of the second reply clears only the first.
+ expect((await markThread(s.tabId, s.web, root, await sequenceOf(first))).status).toBe(200)
+ expect((await items(s.tabId)).map(i => [i.messageId, i.read])).toEqual([[second, false], [first, true]])
+ expect((await markThread(s.tabId, s.web, root, await sequenceOf(second))).status).toBe(200)
+ expect((await items(s.tabId)).map(i => i.read)).toEqual([true, true])
+ expect((await derived(s.tabId, owner)).activityDigest).toBe(before)
+ // An older mark afterwards moves nothing back.
+ await markThread(s.tabId, s.web, root, await sequenceOf(first))
+ expect((await items(s.tabId)).map(i => i.read)).toEqual([true, true])
+ })
+
+ it('leaves another person\'s rows, other threads\' rows and reactions unread when a thread is read', async () => {
+ const s = await scene()
+ const root = await send(s.tabId, s.web, 'Owner root')
+ const other = await send(s.tabId, s.web, 'Owner other root')
+ const peerRoot = await send(s.tabId, s.web, 'Peer root', peer)
+ await send(s.tabId, s.web, 'Answer to peer', owner, peerRoot)
+ await send(s.tabId, s.web, 'Answer', owner, root, s.worker)
+ await send(s.tabId, s.web, 'Answer elsewhere', owner, other, s.worker)
+ await react(s.tabId, s.web, root, true, peer)
+ const newest = await sequenceOf((await db.superTabMessage.findFirstOrThrow({ where: { tabId: s.tabId }, orderBy: { sequence: 'desc' } })).id)
+ await markThread(s.tabId, s.web, root, newest)
+ expect((await items(s.tabId)).map(i => [i.text, i.read])).toEqual([[null, false], ['Answer elsewhere', false], ['Answer', true]].map(([text, read]) =>
+ [text ?? 'Owner root', read]))
+ expect((await items(s.tabId, peer)).map(i => i.read)).toEqual([false])
+ })
+
+ it('marks a reply also sent to the chat read when the chat is read, and a thread-only reply not', async () => {
+ const s = await scene()
+ const root = await send(s.tabId, s.web, 'Owner root')
+ const only = await send(s.tabId, s.web, 'Only in the thread', peer, root)
+ const also = await sendAlso(s.tabId, s.web, 'Also in the chat', peer, root)
+ const newest = await sequenceOf(also)
+ expect((await markChat(s.tabId, s.web, newest)).status).toBe(200)
+ expect((await items(s.tabId)).map(i => [i.messageId, i.read])).toEqual([[also, true], [only, false]])
+ expect((await markThread(s.tabId, s.web, root, await sequenceOf(only))).status).toBe(200)
+ expect((await items(s.tabId)).map(i => i.read)).toEqual([true, true])
+ })
+
+ it('leaves a row written before rows kept a sequence unread by a read', async () => {
+ const s = await scene()
+ const root = await send(s.tabId, s.web, 'Owner root')
+ const reply = await send(s.tabId, s.web, 'Peer answers', peer, root)
+ await db.superTabActivity.updateMany({ where: { tabId: s.tabId }, data: { sequence: null, alsoInChat: null } })
+ await markThread(s.tabId, s.web, root, await sequenceOf(reply))
+ await markChat(s.tabId, s.web, await sequenceOf(reply))
+ expect((await items(s.tabId)).map(i => i.read)).toEqual([false])
+ })
+
+ it('writes no row for a Buddy session\'s ended line, and still one for its answers', async () => {
+ const s = await scene()
+ const root = await send(s.tabId, s.web, 'Owner root')
+ const rootRow = await db.superTabMessage.findUniqueOrThrow({ where: { id: root } })
+ const draft = (id: string, source?: Record<string, unknown>) => ({ id, conversationId: s.web, text: 'Reply', replyTo: root, recipients: [], thread: root,
+ author: { kind: 'agent' as const, id: s.worker, name: 'worker-harness', membershipGeneration: 'fixture' }, ...(source ? { source } : {}) })
+ const write = (...ids: [string, Record<string, unknown> | undefined][]) => db.$transaction(tx => writeReplyActivity(tx, s.tabId,
+ ids.map(([id, source]) => draft(id, source)), new Map(ids.map(([id], i) => [id, rootRow.sequence + 1 + i])), Date.now()))
+ await write(['ended-line', { kind: SESSION_ENDED_KIND, reason: 'done', thread: root }])
+ expect(await db.superTabActivity.count({ where: { tabId: s.tabId } })).toBe(0)
+ await write(['answer', undefined])
+ expect(await db.superTabActivity.findMany({ where: { tabId: s.tabId }, select: { messageId: true, sequence: true, alsoInChat: true } }))
+ .toEqual([{ messageId: 'answer', sequence: rootRow.sequence + 1, alsoInChat: null }])
+ })
+
it('is read at most ACTIVITY_READS times per window by one person', async () => {
const s = await scene()
for (let i = 0; i < ACTIVITY_READS; i++) expect((await activity(s.tabId)).status).toBe(200)
diff --git a/backend/prisma/schema.prisma b/backend/prisma/schema.prisma
index 971e5ebd0..aff873d9d 100644
--- a/backend/prisma/schema.prisma
+++ b/backend/prisma/schema.prisma
@@ -1183,9 +1183,16 @@ model SuperTabActivity {
createdAt DateTime
/// When the person saw it, on any device; unset while unread.
readAt DateTime?
+ /// A reply's message sequence in its chat, so reading its thread or chat past it marks the row read (activity.ts); unset on a
+ /// reaction and on a row written before it was kept, which only opening Activity reads.
+ sequence Int?
+ /// A reply also shown in the chat's main stream: the chat mark reads it, as well as its thread's.
+ alsoInChat Boolean?
/// A person's rows, newest first: the list and the digest.
@@index([tabId, personId, createdAt])
+ /// One thread's or chat's rows of a person, for the read marks that clear them (activity.ts markActivityThreadRead).
+ @@index([tabId, personId, conversationId, threadId])
/// The sweep's rows past their expiry (activity.ts sweepActivity); no TTL option, which the app user cannot set (#2238).
@@index([createdAt])
}
diff --git a/backend/src/superTabs/activity.ts b/backend/src/superTabs/activity.ts
index 531583272..fffe6308c 100644
--- a/backend/src/superTabs/activity.ts
+++ b/backend/src/superTabs/activity.ts
@@ -18,6 +18,7 @@ import type { Prisma, PrismaClient } from '@prisma/client'
import type { AuthUser } from '../lib/ssoAuth.js'
import { createRateLimiter } from '../lib/rateLimit.js'
import { agentOnly, isLeads, stableId, type Actor, type Author, type Conversation, type MessageDraft, type SuperTabState } from './model.js'
+import { SESSION_ENDED_KIND } from './buddySessions.js'
import { canReadGroup, projectOf } from './projects.js'
import { groupsBy, readBy } from './parts/indexed.js'
import { usernameOf } from './usernames.js'
@@ -41,9 +42,11 @@ const own = (author: { kind?: string; id?: string } | undefined, personId: strin
/** Activity rows for the thread replies among `messages`: one for the person who wrote the thread's root and one for the person
* who wrote the message replied to, unless they wrote the reply. A notice for agents alone is nobody's activity, and a root or
- * quoted message counts only in the reply's own chat. Those messages by id in one read. */
-export async function writeReplyActivity(tx: Tx, tabId: string, messages: MessageDraft[], now: number): Promise<void> {
- const replies = messages.filter(m => m.thread && m.thread !== m.id && !agentOnly(m.source ?? null, m.recipients))
+ * quoted message counts only in the reply's own chat. A Buddy session's ended line is nobody's activity either. Each row keeps its
+ * message's `sequence` (from `sequences`) and whether it is also in the chat, so a thread or chat mark reads it (markActivityThreadRead).
+ * Those messages by id in one read. */
+export async function writeReplyActivity(tx: Tx, tabId: string, messages: MessageDraft[], sequences: ReadonlyMap<string, number>, now: number): Promise<void> {
+ const replies = messages.filter(m => m.thread && m.thread !== m.id && !agentOnly(m.source ?? null, m.recipients) && m.source?.kind !== SESSION_ENDED_KIND)
if (!replies.length) return
const ids = [...new Set(replies.flatMap(m => [m.thread!, ...(m.replyTo ? [m.replyTo] : [])]))]
// By id through its index, as a plain $in (parts/indexed.ts): Prisma's `in` plans slowly.
@@ -56,7 +59,8 @@ export async function writeReplyActivity(tx: Tx, tabId: string, messages: Messag
return row && row.conversationId === m.conversationId && by?.kind === 'person' && by.id && !own(m.author, by.id) ? [by.id] : []
}))
return [...people].map(personId => ({ id: stableId(tabId, 'reply', m.id, personId), tabId, personId, kind: 'reply', conversationId: m.conversationId,
- messageId: m.id, threadId: m.thread!, actorKind: m.author.kind, actorId: m.author.id, emoji: null, createdAt: new Date(now), readAt: null }))
+ messageId: m.id, threadId: m.thread!, actorKind: m.author.kind, actorId: m.author.id, emoji: null, createdAt: new Date(now), readAt: null,
+ ...sequences.has(m.id) ? { sequence: sequences.get(m.id)! } : {}, ...m.alsoInChat ? { alsoInChat: true } : {} }))
})
if (data.length) await tx.superTabActivity.createMany({ data })
}
@@ -164,6 +168,27 @@ export async function markActivityRead(db: PrismaClient, tabId: string, personId
return moved.count
}
+/** Marks the person's unread reply rows of thread `threadId` read when their thread mark stands at `sequence`: those at or below it,
+ * in one update on every device. Only their own; a row without a sequence (written before they were kept) is not matched:
+ * `gt: 0` keeps it out, since Prisma's `lte` alone matches a null. */
+export async function markActivityThreadRead(db: PrismaClient, read: { tabId: string; personId: string; conversationId: string; threadId: string
+ sequence: number; now: number }): Promise<number> {
+ const { tabId, personId, conversationId, threadId, sequence, now } = read
+ const moved = await db.superTabActivity.updateMany({ where: { tabId, personId, conversationId, threadId, kind: 'reply', sequence: { gt: 0, lte: sequence }, ...unread },
+ data: { readAt: new Date(now) } })
+ return moved.count
+}
+
+/** Marks the person's unread reply rows of a chat read when their chat mark stands at `sequence`: those also shown in the chat at or
+ * below it. A reply only in its thread waits for its thread's mark, as the chat read leaves it unread (threadMarkSeeds.ts). */
+export async function markActivityChatRead(db: PrismaClient, read: { tabId: string; personId: string; conversationId: string; sequence: number; now: number }):
+ Promise<number> {
+ const { tabId, personId, conversationId, sequence, now } = read
+ const moved = await db.superTabActivity.updateMany({ where: { tabId, personId, conversationId, kind: 'reply', alsoInChat: true, sequence: { gt: 0, lte: sequence }, ...unread },
+ data: { readAt: new Date(now) } })
+ return moved.count
+}
+
/** The hourly sweep (sweeps.ts): deletes rows older than ACTIVITY_EXPIRY_MS by the age index, in batches. No TTL index: the app
* user may not set one on an index `db push` built (#2238), as thread marks. */
export async function sweepActivity(db: PrismaClient, now: number): Promise<number> {
diff --git a/backend/src/superTabs/read/service.ts b/backend/src/superTabs/read/service.ts
index e47ae049d..e42cd5ceb 100644
--- a/backend/src/superTabs/read/service.ts
+++ b/backend/src/superTabs/read/service.ts
@@ -9,7 +9,7 @@ import { agentOnly, author, fail, groupForBuddy, isLeads, seenMachineIds, stable
import { mentionsDigest, swarmsWithTags, waitingMentions, waitingTagConversations } from '../mentions.js'
import { decisionsWaiting } from '../decisions.js'
import { readMarks, readThreadMarks, writeReadMark, writeThreadFollow, writeThreadMark } from '../readMarks.js'
-import { activityDigest, listActivity, markActivityRead, type ActivityItem } from '../activity.js'
+import { activityDigest, listActivity, markActivityChatRead, markActivityRead, markActivityThreadRead, type ActivityItem } from '../activity.js'
import { readChatSettings, writeChatSetting, type NotifyLevel } from '../chatSettings.js'
import { deliveredCopies } from '../pageReads.js'
import { readBy } from '../parts/indexed.js'
@@ -232,7 +232,10 @@ export class SwarmReads {
const next = Math.min(sequence, group.data!.lastMessageSequence), now = this.now()
const held = await this.db.superTabReadMark.findUnique({ where: { id: stableId(tabId, conversationId, user.sub) }, select: { sequence: true } })
await seedThreadMarks(this.db, { tabId, state, personId: user.sub, conversationId, old: held?.sequence ?? 0, next, now })
- return { sequence: await writeReadMark(this.db, { tabId, personId: user.sub, conversationId, sequence: next, now }) }
+ const stored = await writeReadMark(this.db, { tabId, personId: user.sub, conversationId, sequence: next, now })
+ // The replies also in the chat that the mark passes are read in Activity too (activity.ts).
+ await markActivityChatRead(this.db, { tabId, personId: user.sub, conversationId, sequence: stored, now })
+ return { sequence: stored }
}
/** Moves the person's mark of thread `threadId` in a conversation they can read forward, never past the conversation's
@@ -242,8 +245,11 @@ export class SwarmReads {
* an unreadable conversation or project included, is the same refusal. Only a person reading as themselves has marks. */
async markThreadRead(user: AuthUser, tabId: string, conversationId: string, threadId: string, sequence: number): Promise<{ sequence: number }> {
const newest = await this.readableThread(user, tabId, conversationId, threadId)
- return { sequence: await writeThreadMark(this.db, { tabId, personId: user.sub, conversationId, threadId, sequence: Math.min(sequence, newest),
- now: this.now() }) }
+ const now = this.now()
+ const stored = await writeThreadMark(this.db, { tabId, personId: user.sub, conversationId, threadId, sequence: Math.min(sequence, newest), now })
+ // The thread's replies the mark passes are read in Activity too (activity.ts).
+ await markActivityThreadRead(this.db, { tabId, personId: user.sub, conversationId, threadId, sequence: stored, now })
+ return { sequence: stored }
}
/** Stores the person's Follow (true), Unfollow (false) or neither (null) of thread `threadId` (readMarks.ts writeThreadFollow),
diff --git a/backend/src/superTabs/store.ts b/backend/src/superTabs/store.ts
index f2d78c1e1..04be6d33b 100644
--- a/backend/src/superTabs/store.ts
+++ b/backend/src/superTabs/store.ts
@@ -1719,7 +1719,7 @@ export class SuperTabStore {
const leadAt = (state: SuperTabState) => state.conversations.find(c => c.id === ledId)?.leadAction?.at
if (ledId && leadAt(effects.state) !== undefined && leadAt(effects.state) !== leadAt(original)) await dropHeldTags(tx, tabId, ledId, context.now)
await writeMentions(tx, tabId, effects.state, effects.messages, context.now)
- await writeReplyActivity(tx, tabId, effects.messages, context.now)
+ await writeReplyActivity(tx, tabId, effects.messages, sequences, context.now)
if (command.type === 'mention.done') await markDone(tx, tabId, command.mentionId, context.mention!.personId, context.now)
if (command.type === 'message.react') await this.writeReaction(tx, tabId, actor, command, context.now)
if (context.avatarUpload) {
diff --git a/docs/plans/2026-11-02-activity-read-with-thread-plan.md b/docs/plans/2026-11-02-activity-read-with-thread-plan.md
new file mode 100644
index 000000000..0634fb84d
--- /dev/null
+++ b/docs/plans/2026-11-02-activity-read-with-thread-plan.md
@@ -0,0 +1,77 @@
+# Activity rows clear when their thread or chat is read Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** The Activity badge stops counting replies the person already read in their thread or chat, and a Buddy session ending adds no Activity row.
+
+**Architecture:** Each reply Activity row remembers its message `sequence` and whether the reply is `alsoInChat`. When a person's thread mark (or chat mark) moves, one `updateMany` sets `readAt` on that person's unread reply rows in that thread (or chat, for rows also sent to the chat) at or below the stored mark. The Activity digest is computed from unread rows, so it moves with them and every device sees the rows cleared. `writeReplyActivity` skips `buddy-session-ended` notices.
+
+**Tech Stack:** TypeScript, Fastify, Prisma on MongoDB, vitest with `mongodb-memory-server-core`.
+
+**Spec:** Task #2110 brief (Diego): evidence at `backend/src/superTabs/activity.ts` `writeReplyActivity` / `markActivityRead`, `backend/src/superTabs/read/service.ts` `markRead` / `markThreadRead`, `buddySessions.ts` `endSessionEntry`.
+
+## Global Constraints
+
+- Swarm code stays out of `cli/src/core`.
+- Reactions rows are left as they are (only `kind: 'reply'` rows clear with a read).
+- A client reads Activity again only when the digest moves, never on a timer (activity.ts header).
+- An older backend reads and writes a tab that has the new fields; rows without `sequence` keep today's behavior (cleared by opening Activity).
+- PR body starts with "Requested by [email protected] through Harness." Full Super Tab integration suite before Ready.
+
+## Review Focus
+
+- A thread mark only clears rows of that person, that conversation and that thread, at or below the stored mark (a lower mark than the held one never clears more).
+- A chat mark clears only rows also sent to the chat; a reply only in its thread stays unread until that thread is read.
+- Another person's rows, and reaction rows, never clear.
+- Old rows without `sequence` stay unread and are not an error.
+- A Buddy-session-ended line writes no row, while a normal Buddy session answer still does.
+
+## Design
+
+- growth: rows still expire after 30 days (sweepActivity); the two new fields add a number and a boolean per row.
+- concurrency: `updateMany` on rows only sets `readAt` where it is still unset; two devices marking at once are idempotent. No lock.
+- read cost: the update matches by the new index `(tabId, personId, conversationId, threadId)`, touching only that thread's rows.
+- scale: 10x the rows per person is still bounded by the 30-day expiry and that index; the metric to watch is mark request latency.
+- compatibility: old rows have no `sequence` (never match `lte`), old backends ignore the new fields; old clients are unchanged (the digest and `read` flag are the same shape).
+- migration + rollback: none to run (optional fields, `db push` builds the index); rolling back leaves extra fields that nothing reads.
+- audience: the server writes `readAt` only on the marking person's own rows after the existing read checks of `markRead` / `markThreadRead`.
+- identity: the person is the signed-in user (`user.sub`), as for read marks.
+- failure: a failed Activity update fails the mark request, which the client retries as it does a mark; nothing is skipped silently.
+- platforms: backend only; Desktop already reads the digest.
+
+---
+
+### Task 1: Store sequence on Activity rows and skip session-ended lines
+
+**Files:**
+- Modify: `backend/prisma/schema.prisma` (SuperTabActivity: `sequence Int?`, `alsoInChat Boolean?`, index)
+- Modify: `backend/src/superTabs/activity.ts` (`writeReplyActivity`)
+- Modify: `backend/src/superTabs/store.ts` (pass `sequences` to `writeReplyActivity`)
+- Test: `backend/integration/superTabActivity.test.ts`
+
+**Interfaces:**
+- Produces: `writeReplyActivity(tx: Tx, tabId: string, messages: MessageDraft[], sequences: ReadonlyMap<string, number>, now: number): Promise<void>`; rows carry `sequence` and `alsoInChat`.
+
+- [ ] **Step 1: Write the failing test** `a buddy-session-ended line writes no Activity row` (an ended line replying in a person's thread: no row; a normal reply: a row with `sequence` and `alsoInChat` set).
+- [ ] **Step 2: Run it:** `cd backend && npx vitest run --config vitest.integration.config.ts integration/superTabActivity.test.ts -t "session-ended"`; expected FAIL.
+- [ ] **Step 3: Implement** the schema fields and index, then skip `source.kind === SESSION_ENDED_KIND` and write `sequence` / `alsoInChat` in `writeReplyActivity`.
+- [ ] **Step 4: Run it again;** expected PASS.
+- [ ] **Step 5: Commit.**
+
+### Task 2: A thread or chat mark clears the person's reply rows
+
+**Files:**
+- Modify: `backend/src/superTabs/activity.ts` (`markActivityThreadRead`, `markActivityChatRead`)
+- Modify: `backend/src/superTabs/read/service.ts` (`markRead`, `markThreadRead`)
+- Test: `backend/integration/superTabActivity.test.ts`
+
+**Interfaces:**
+- Consumes: `writeThreadMark` / `writeReadMark` return the stored mark.
+- Produces: `markActivityThreadRead(db, { tabId, personId, conversationId, threadId, sequence, now }): Promise<number>` and `markActivityChatRead(db, { tabId, personId, conversationId, sequence, now }): Promise<number>`, each one `updateMany` of unread `kind: 'reply'` rows with `sequence <= mark` (chat: also `alsoInChat: true`).
+
+- [ ] **Step 1: Write the failing tests:** (a) root by the owner, two worker replies, thread read past them: both rows read and the digest back to its value before the replies; another person's digest unchanged; (b) a thread mark below a reply leaves that reply unread; (c) a reply also sent to the chat clears by the chat mark, a thread-only reply does not; (d) a reaction row stays unread after both marks.
+- [ ] **Step 2: Run them;** expected FAIL on main behavior.
+- [ ] **Step 3: Implement** both functions and call them in `markThreadRead` and `markRead` with the stored mark.
+- [ ] **Step 4: Run them;** expected PASS.
+- [ ] **Step 5: Run the full Super Tab integration suite and typecheck;** expected PASS.
+- [ ] **Step 6: Commit, push, open the pull request (draft until the suite passes).**