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.

Super Tabs: skill-update notices reach only their agent (#1681)

0xken15da7e812c8956
diff --git a/backend/integration/superTabs.test.ts b/backend/integration/superTabs.test.ts
index bdcafbc7e..49f709d42 100644
--- a/backend/integration/superTabs.test.ts
+++ b/backend/integration/superTabs.test.ts
@@ -1117,6 +1117,83 @@ describe('Super Tabs on a real Mongo replica set', () => {
expect(text).not.toMatch(/Only|@/)
})
+ it('delivers a Lead\'s agent-only notice to the Lead once and shows it to no person in the project chat', async () => {
+ const { tab, lead } = await fixture()
+ await invite(tab)
+ const before = (await store.read(owner, tab)).state.conversations.find(c => c.id === 'lead')!.lastMessageSequence
+ const notice: Command = { type: 'message.send', conversationId: 'lead', text: 'Harness updated your built-in swarm-lead skill.',
+ replyTo: null, recipientIds: [lead], agentOnly: true }
+ const sent = await run(tab, notice, host, lead, 'skill-notice')
+ await run(tab, notice, host, lead, 'skill-notice')
+ const deliveries = (await store.deliveries(host, tab, lead)).filter(d => d.messageId === sent.result.messageId)
+ expect(deliveries).toHaveLength(1)
+ for (const person of [owner, peer]) {
+ expect((await store.messages(person, tab, 'lead', {})).messages).toEqual([])
+ expect((await store.messages(person, tab, 'lead', { messageId: sent.result.messageId as string })).messages).toEqual([])
+ }
+ expect((await store.read(owner, tab)).state.conversations.find(c => c.id === 'lead')!.lastMessageSequence).toBe(before)
+ expect((await store.messages(host, tab, 'lead', {}, lead)).messages.map(m => m.text)).toEqual(['Harness updated your built-in swarm-lead skill.'])
+ // Typed through the normal claim; a hold while the input box is busy writes no row people would see.
+ const claimed = await store.delivery(host, tab, lead, deliveries[0]!.id, { type: 'claim', claimId: 'claim' })
+ expect(claimed.message).toMatchObject({ text: 'Harness updated your built-in swarm-lead skill.', source: { kind: 'agent-only' } })
+ expect(await store.delivery(host, tab, lead, deliveries[0]!.id, { type: 'hold', claimId: 'claim', reason: 'team_waiting_draft' })).toEqual({ noticed: false })
+ expect((await store.messages(owner, tab, 'lead', {})).messages).toEqual([])
+ })
+
+ it('delivers a worker\'s agent-only notice once in its group and lists it for no person and not for its Lead', async () => {
+ const { tab, lead } = await fixture()
+ const group = (await run(tab, { type: 'conversation.create', title: 'Worker task', brief: 'Work', checks: [{ description: 'Done', independent: false }] })).result.conversationId as string
+ const worker = (await run(tab, { type: 'agent.add', conversationId: group, machineId: 'test-host', harnessId: randomUUID(), name: 'Worker', configuration: config, lead: false })).result.agentId as string
+ await run(tab, { type: 'work.assign', conversationId: group, agentId: worker })
+ const before = (await store.read(owner, tab)).state.conversations.find(c => c.id === group)!.lastMessageSequence
+ const notice: Command = { type: 'message.send', conversationId: group, text: 'Harness updated your built-in swarm-dev skill.',
+ replyTo: null, recipientIds: [worker], agentOnly: true }
+ const sent = await run(tab, notice, host, worker, 'worker-notice')
+ await run(tab, notice, host, worker, 'worker-notice')
+ expect((await store.deliveries(host, tab, worker)).filter(d => d.messageId === sent.result.messageId)).toHaveLength(1)
+ expect((await store.deliveries(host, tab, lead)).filter(d => d.messageId === sent.result.messageId)).toEqual([])
+ expect((await store.messages(owner, tab, group, {})).messages.map(m => m.id)).not.toContain(sent.result.messageId)
+ expect((await store.messages(host, tab, group, {}, lead)).messages.map(m => m.id)).not.toContain(sent.result.messageId)
+ expect((await store.messages(host, tab, group, {}, worker)).messages.map(m => m.id)).toContain(sent.result.messageId)
+ expect((await store.read(owner, tab)).state.conversations.find(c => c.id === group)!.lastMessageSequence).toBe(before)
+ })
+
+ it('reads past more than a page of hidden notices so a person still reaches every later message', async () => {
+ const { tab, lead } = await fixture()
+ const first = (await run(tab, message('Before the notices.'))).result.messageId as string
+ for (let i = 0; i < 120; i++) {
+ await run(tab, { type: 'message.send', conversationId: 'lead', text: `Notice ${i}.`, replyTo: null, recipientIds: [lead], agentOnly: true }, host, lead)
+ }
+ const last = (await run(tab, message('After the notices.'))).result.messageId as string
+ // Desktop's first read, then its next read after the last row it shows (desktop/lib/super_tabs/controller.dart).
+ const opened = await store.messages(owner, tab, 'lead', {})
+ expect(opened.messages.map(m => m.id)).toEqual([first, last])
+ expect(opened.next).toBeNull()
+ const tail = opened.messages[0]!.sequence
+ expect((await store.messages(owner, tab, 'lead', { after: tail })).messages.map(m => m.id)).toEqual([last])
+ expect((await store.messages(owner, tab, 'lead', { before: opened.messages[1]!.sequence })).messages.map(m => m.id)).toEqual([first])
+ // The Lead pages through all of its own notices, a full page then the rest.
+ const page = await store.messages(host, tab, 'lead', {}, lead)
+ expect(page.messages).toHaveLength(100)
+ const rest = await store.messages(host, tab, 'lead', { before: page.next! }, lead)
+ expect([...rest.messages, ...page.messages].map(m => m.text)).toEqual(['Before the notices.', ...Array.from({ length: 120 }, (_, i) => `Notice ${i}.`), 'After the notices.'])
+ expect(rest.next).toBeNull()
+ })
+
+ it('accepts an agent-only notice only from an agent to itself alone', async () => {
+ const { tab, lead } = await fixture()
+ const worker = (await run(tab, { type: 'agent.add', conversationId: 'lead', machineId: 'test-host', harnessId: randomUUID(), name: 'Worker', configuration: config, lead: false })).result.agentId as string
+ const notice = (recipientIds: string[]): Command => ({ type: 'message.send', conversationId: 'lead', text: 'Skill changed.', replyTo: null, recipientIds, agentOnly: true })
+ await expect(run(tab, notice([lead]))).rejects.toMatchObject({ code: 'INVALID_RECIPIENT' })
+ await expect(run(tab, notice([worker]), host, lead)).rejects.toMatchObject({ code: 'INVALID_RECIPIENT' })
+ await expect(run(tab, notice([lead, worker]), host, lead)).rejects.toMatchObject({ code: 'INVALID_RECIPIENT' })
+ await expect(run(tab, notice([]), host, lead)).rejects.toMatchObject({ code: 'INVALID_RECIPIENT' })
+ // A tag would tell a person about a notice they cannot see.
+ await invite(tab)
+ await expect(run(tab, { ...notice([lead]), mentions: [peer.sub] } as Command, host, lead)).rejects.toMatchObject({ code: 'INVALID_RECIPIENT' })
+ expect((await store.messages(owner, tab, 'lead', {})).messages).toEqual([])
+ })
+
it('stores the current delivery hold and its first time even after the compatibility notice exists', async () => {
const { tab, lead } = await fixture()
let now = Date.now()
diff --git a/backend/src/superTabs/commands.ts b/backend/src/superTabs/commands.ts
index 75325f880..3a9cf529b 100644
--- a/backend/src/superTabs/commands.ts
+++ b/backend/src/superTabs/commands.ts
@@ -4,7 +4,7 @@ import { assignAgentDisplayNames } from './agentNames.js'
import { z } from 'zod'
import {
activeWork, actorKey, agent, agentRole, author, conversation, crossProjectActive, fail, isLeads, person, stableId, syncLeads, numberConversations, nextConversationNumber, renderWorkTask,
- finishWorker, requireWorkerDecisions, reviewing,
+ finishWorker, requireWorkerDecisions, reviewing, AGENT_ONLY,
type Actor, type Agent, type Author, type CommandEffects, type Conversation, type SuperTabState,
} from './model.js'
import { routeRecordSchema, routeTitle, startedAs, type RouteCandidate, type RouteDecision, type RouteFinal, type RouteOverride } from './routeRecord.js'
@@ -113,7 +113,7 @@ export const commandSchema = z.discriminatedUnion('type', [
z.object({ type: z.literal('member.remove'), userId: id }).strict(),
// Text may be empty when the message carries files; applyCommand checks that one of them is there.
z.object({ type: z.literal('message.send'), conversationId: id, text: z.string().trim().max(32_000), replyTo: id.nullable(), recipientIds: z.array(id).max(16),
- attachmentIds: z.array(id).max(MAX_ATTACHMENTS).optional(), mentions: z.array(id).max(MAX_MENTIONS).optional() }).strict(),
+ attachmentIds: z.array(id).max(MAX_ATTACHMENTS).optional(), mentions: z.array(id).max(MAX_MENTIONS).optional(), agentOnly: z.literal(true).optional() }).strict(),
z.object({ type: z.literal('mention.done'), mentionId: id }).strict(),
z.object({ type: z.literal('delivery.resolve'), deliveryId: id, resolution: z.enum(['received', 'resend', 'cancel']) }).strict(),
z.object({ type: z.literal('work.define'), conversationId: id, brief: text.optional(), task: task.optional(), checks: z.array(check).min(1).max(40) }).strict()
@@ -1220,8 +1220,12 @@ export function applyCommand(original: SuperTabState, actor: Actor, input: Comma
agent(state, id)
if (!group.agentIds.includes(id)) fail('INVALID_RECIPIENT', 'Choose an agent in this conversation.', 400)
}
+ // A tag would tell a person about a notice they cannot see.
+ if (command.agentOnly && (actor.kind !== 'agent' || recipients.length !== 1 || recipients[0] !== actor.agentId || mentions.length)) {
+ fail('INVALID_RECIPIENT', 'An agent sends an agent-only notice to itself alone.', 400)
+ }
// The transcript still accepts a human message while the lead is unavailable. The UI can say why no delivery was created.
- message(group.id, command.text, recipients, command.replyTo, undefined, attachments, mentions)
+ message(group.id, command.text, recipients, command.replyTo, command.agentOnly ? AGENT_ONLY : undefined, attachments, mentions)
break
}
case 'delivery.resolve': {
diff --git a/backend/src/superTabs/model.ts b/backend/src/superTabs/model.ts
index 19dbec89c..eed64a652 100644
--- a/backend/src/superTabs/model.ts
+++ b/backend/src/superTabs/model.ts
@@ -232,6 +232,9 @@ export interface MessageDraft {
/** People a Lead tagged (mentions.ts). */
mentions?: string[]
}
+/** A notice for one agent alone (a skill update): delivered to it like any message, never shown to people or other agents. */
+export const AGENT_ONLY = { kind: 'agent-only' }
+export const agentOnly = (source: unknown): boolean => (source as { kind?: unknown } | null | undefined)?.kind === AGENT_ONLY.kind
export interface CommandEffects {
state: SuperTabState
messages: MessageDraft[]
diff --git a/backend/src/superTabs/store.ts b/backend/src/superTabs/store.ts
index 9812056cc..731e3a58d 100644
--- a/backend/src/superTabs/store.ts
+++ b/backend/src/superTabs/store.ts
@@ -1,6 +1,6 @@
import { contributedEngines, expireRemovals, hostLocalGrid, machineContribution, machineObservationSchema, machineSlots, recordAgentPresence, removalPreview, swarmGridRow, type MachineObservation } from './machines.js'
import { createHash } from 'node:crypto'
-import type { Prisma, PrismaClient, SuperTab, SuperTabDelivery } from '@prisma/client'
+import type { Prisma, PrismaClient, SuperTab, SuperTabDelivery, SuperTabMessage } from '@prisma/client'
import type { AuthUser } from '../lib/ssoAuth.js'
import { machineAlive } from '../lib/prisma.js'
import { machineShareGrant, sharedVia } from '../lib/machineSharePolicy.js'
@@ -15,7 +15,7 @@ import { bindSession, makeProjectPrivate } from './sessionScope.js'
import { noteProjectReports, projectUpdateRequest } from './projectUpdates.js'
import { revokeNativeContexts, SuperTabNativeStore } from './native.js'
import {
- activeWork, actorKey, agent, appendPullRequestUrls, author, conversation, createSuperTab, fail, person, stableId, visibleState, finishWorker,
+ activeWork, actorKey, agent, agentOnly, appendPullRequestUrls, author, conversation, createSuperTab, fail, person, stableId, visibleState, finishWorker,
SuperTabError, isLeads, parkLaterConversations, syncLeads, type Actor, type Agent, type Assignment, type Author, type MessageDraft, type SuperTabState,
} from './model.js'
import { holdNoticeText, type HoldReason } from './holdNotice.js'
@@ -489,9 +489,11 @@ export class SuperTabStore {
if (dispatched) context.routeDecision = await readDecision(tx, tabId, dispatched) ?? undefined
await restorePullRequestUrls(tx, tabId, original)
const effects = applyCommand(original, actor, command, context)
+ // An agent-only notice changes nothing people see: no link, no unread mark, no project report.
+ const shown = effects.messages.filter(message => !agentOnly(message.source))
for (const group of effects.state.conversations) {
appendPullRequestUrls(group, [
- ...effects.messages.filter(message => message.conversationId === group.id).map(message => message.text),
+ ...shown.filter(message => message.conversationId === group.id).map(message => message.text),
...group.checks.map(check => check.evidence), group.assignment?.result,
])
}
@@ -550,8 +552,8 @@ export class SuperTabStore {
} })
}
}
- for (const message of effects.messages) conversation(effects.state, message.conversationId).lastMessageSequence = revision
- noteProjectReports(effects.state, effects.messages, revision, context.now)
+ for (const message of shown) conversation(effects.state, message.conversationId).lastMessageSequence = revision
+ noteProjectReports(effects.state, shown, revision, context.now)
if (command.type === 'agent.release' && command.decision === 'stop') {
const target = agent(effects.state, command.agentId)
const assignmentId = `release-${target.releaseId}`
@@ -891,12 +893,20 @@ export class SuperTabStore {
return transaction(this.db, async tx => {
const row = await this.row(tx, user, tabId)
const state = stateOf(row)
- readConversation(state, await this.actor(tx, user, state, asAgentId), conversationId)
+ const actor = await this.actor(tx, user, state, asAgentId)
+ readConversation(state, actor, conversationId)
const forward = cursor.after !== undefined
- const rows = await tx.superTabMessage.findMany({ where: { tabId, conversationId,
+ const where = { tabId, conversationId,
...(cursor.messageId ? { id: cursor.messageId } : {}),
- ...(forward ? { sequence: { gt: cursor.after } } : cursor.before !== undefined ? { sequence: { lt: cursor.before } } : {}) },
- orderBy: { sequence: forward ? 'asc' : 'desc' }, take: 101 })
+ ...(forward ? { sequence: { gt: cursor.after } } : cursor.before !== undefined ? { sequence: { lt: cursor.before } } : {}) }
+ // An agent-only notice is listed for its own recipient alone. Hidden rows never shorten a page: Desktop reads on from the
+ // last row it shows, so the page reads past them until it has 101 rows this reader may see, or reaches the end.
+ const rows: SuperTabMessage[] = []
+ for (let skip = 0; rows.length <= 100; skip += 101) {
+ const batch = await tx.superTabMessage.findMany({ where, orderBy: { sequence: forward ? 'asc' : 'desc' }, skip, take: 101 })
+ rows.push(...batch.filter(m => !agentOnly(m.source) || (actor.kind === 'agent' && m.recipientIds.includes(actor.agentId))))
+ if (batch.length < 101) break
+ }
const page = rows.slice(0, 100)
const next = rows.length > 100 ? page.at(-1)!.sequence : null
if (!forward) page.reverse()
@@ -1254,6 +1264,8 @@ export class SuperTabStore {
private async holdNotice(tx: Transaction, row: SuperTab, state: SuperTabState, delivery: SuperTabDelivery, reason: HoldReason) {
const id = stableId('hold-notice', delivery.tabId, delivery.id)
if (delivery.status !== 'claimed') return { noticed: false }
+ // Nobody can see an agent-only notice, so nobody is told it waits; the host keeps holding it.
+ if (agentOnly((await tx.superTabMessage.findUnique({ where: { id: delivery.messageId }, select: { source: true } }))?.source)) return { noticed: false }
const notice = await tx.superTabMessage.findUnique({ where: { id } })
if (notice && delivery.holdReason === reason && delivery.holdSince) return { noticed: false }
// The notice is only sent once for older Desktops; the inline receipt keeps the current reason.
diff --git a/cli/src/superTabs/host.spec.ts b/cli/src/superTabs/host.spec.ts
index 1f480a83e..cb0ca7f7e 100644
--- a/cli/src/superTabs/host.spec.ts
+++ b/cli/src/superTabs/host.spec.ts
@@ -218,6 +218,12 @@ describe('Super Tab native delivery handoff', () => {
expect(vi.mocked(t.core.turns.deliver).mock.calls[0]?.[1]).toContain('Leads coordinate: assign multi-part or 15+ minute work to Swarm agent groups; do only answers, lookups and work under 15 minutes yourself; your subagents only read/look up.')
})
+ it('types only the notice for an agent-only delivery, with no invitation to reply in the conversation', async () => {
+ const t = setup({ text: 'Harness updated your built-in swarm-lead skill.', source: { kind: 'agent-only' } })
+ await t.open().tick()
+ expect(t.core.turns.deliver).toHaveBeenCalledWith('harness', 'Harness updated your built-in swarm-lead skill.', 'team:service:superTabs:delivery')
+ })
+
it('keeps a slow configuration observation out of the native delivery and lease path', async () => {
const t = setup(), host = t.open()
vi.mocked(t.core.agents.byAgent).mockReturnValue({ agentId: 'harness', engine: 'claude' } as never)
@@ -1144,6 +1150,9 @@ describe('built-in skill text after a CLI update', () => {
/** Backend calls held until the test releases them: the roster may change while the refresh waits on one. */
const holds: Array<{ match: (path: string, body: any) => boolean; until: Promise<void> }> = []
let inFlight = 0
+ /** A notice the backend refuses (an older backend, an outage), and every refused request. */
+ let refuse: ((request: any) => { status: number; body: Record<string, unknown> } | undefined) | undefined
+ const refused: Array<{ operationId: string; command: Record<string, any> }> = []
t.core.agents.byAgent = vi.fn(id => sessions[id] as never)
t.core.agents.terminalAvailable = vi.fn(() => true)
t.core.account.backend = vi.fn(async (method, path, body) => {
@@ -1161,6 +1170,8 @@ describe('built-in skill text after a CLI update', () => {
return texts[role] ? { status: 200, body: { data: texts[role] } } : { status: 404, body: { success: false, error: { code: 'NOT_FOUND', message: 'This role is unavailable.' } } }
}
if (path.endsWith('/deliveries')) return { status: 200, body: { data: [] } }
+ const refusal = request?.command?.type === 'message.send' ? refuse?.(request) : undefined
+ if (refusal) { refused.push(request); return refusal }
if (request?.command?.type === 'message.send') {
// As the backend does: a repeated operation gets its first receipt; the same id for a different request is refused.
const prior = receipts.get(request.operationId), same = JSON.stringify(request.command)
@@ -1181,7 +1192,7 @@ describe('built-in skill text after a CLI update', () => {
holds.push({ match, until: new Promise<void>(resolve => { release = resolve }) })
return release
}
- return { t, files, sent, pass, rowRoles, texts, fetched, holdNext, setGroups: (next: typeof groups) => { groups = next }, setMode: (next: typeof mode) => { skillMode = next } }
+ return { t, files, sent, refused, pass, rowRoles, texts, fetched, holdNext, setRefuse: (next: typeof refuse) => { refuse = next }, setGroups: (next: typeof groups) => { groups = next }, setMode: (next: typeof mode) => { skillMode = next } }
}
// Custom roles and skills per project (spec 2026-10-23): on Custom the roster names each agent's role and its text's
@@ -1303,6 +1314,8 @@ describe('built-in skill text after a CLI update', () => {
expect(f.sent.map(s => [s.asAgentId, s.command.recipientIds, s.command.conversationId]).sort()).toEqual([
['a-builder', ['a-builder'], 'work'], ['a-lead', ['a-lead'], 'lead-group'], ['a-reviewer', ['a-reviewer'], 'lead-group']])
for (const s of f.sent) expect(s.command.text).toContain(f.files[s.asAgentId.slice(2)]!)
+ // Only the agent sees its notice; no person reads it in a chat.
+ for (const s of f.sent) expect(s.command.agentOnly).toBe(true)
expect(f.sent.find(s => s.asAgentId === 'a-reviewer')!.command.text).toContain('swarm-review skill')
// A second pass and a restarted host find the files current and say nothing more.
await f.pass(host, 5_000)
@@ -1310,6 +1323,34 @@ describe('built-in skill text after a CLI update', () => {
expect(f.sent).toHaveLength(3)
})
+ it('sends each notice the old way, once, when an older backend refuses the agent-only mark', async () => {
+ const f = syncFixture()
+ f.setRefuse(request => request.command.agentOnly ? { status: 400, body: { success: false,
+ error: { code: 'VALIDATION_ERROR', message: 'command: Unrecognized key: "agentOnly"' } } } : undefined)
+ const host = await f.pass()
+ expect(f.refused.map(r => r.operationId).sort()).toEqual(f.sent.map(s => s.operationId).sort())
+ expect(f.sent.map(s => [s.asAgentId, s.command.recipientIds, 'agentOnly' in s.command]).sort()).toEqual([
+ ['a-builder', ['a-builder'], false], ['a-lead', ['a-lead'], false], ['a-reviewer', ['a-reviewer'], false]])
+ await f.pass(host, 120_000)
+ expect(f.sent).toHaveLength(3)
+ expect(f.refused).toHaveLength(3)
+ })
+
+ it('never falls back to a visible notice on any other refusal, and retries later as before', async () => {
+ const f = syncFixture()
+ let reply = { status: 400, body: { success: false, error: { code: 'VALIDATION_ERROR', message: 'command.text: Too big' } } }
+ f.setRefuse(() => reply)
+ const host = await f.pass()
+ reply = { status: 503, body: { success: false, error: { code: 'BACKEND_UNAVAILABLE', message: 'agentOnly notice could not be stored' } } }
+ await f.pass(host, 60_000)
+ expect(f.sent).toEqual([])
+ expect(f.refused).toHaveLength(6)
+ expect(f.refused.every(r => r.command.agentOnly === true)).toBe(true)
+ f.setRefuse(undefined)
+ await f.pass(host, 60_000)
+ expect(f.sent.map(s => s.command.agentOnly)).toEqual([true, true, true])
+ })
+
it('records a notice that was sent before its record was lost, even after its group changed', async () => {
const f = syncFixture()
await f.pass()
diff --git a/cli/src/superTabs/host.ts b/cli/src/superTabs/host.ts
index dbfd5e608..da44107d9 100644
--- a/cli/src/superTabs/host.ts
+++ b/cli/src/superTabs/host.ts
@@ -730,11 +730,17 @@ export class SuperTabHost {
.filter(group => group.archived !== true && identifier(group.id) && Array.isArray(group.agentIds) && group.agentIds.includes(id))
const group = groups.find(g => g.leadId === id) ?? groups.find(g => object(g.assignment).agentId === id) ?? groups[0]
if (!group || !current()) return false
+ const send = (agentOnly: boolean) => backend(this.core, 'POST', `/api/super-tabs/${target.tabId}/commands`, {
+ // A switch back to an earlier mode's text is a new rewrite, so its count keeps it from reusing that text's id.
+ operationId: `skill-${id}-${refresh.version.slice(0, 32)}${refresh.change ? `-${refresh.change}` : ''}`, asAgentId: id,
+ command: { type: 'message.send', conversationId: group.id, replyTo: null, recipientIds: [id], text: refresh.notice, ...(agentOnly ? { agentOnly } : {}) },
+ })
try {
- await backend(this.core, 'POST', `/api/super-tabs/${target.tabId}/commands`, {
- // A switch back to an earlier mode's text is a new rewrite, so its count keeps it from reusing that text's id.
- operationId: `skill-${id}-${refresh.version.slice(0, 32)}${refresh.change ? `-${refresh.change}` : ''}`, asAgentId: id,
- command: { type: 'message.send', conversationId: group.id, replyTo: null, recipientIds: [id], text: refresh.notice },
+ // Only the agent sees its notice. A backend from before the mark refuses it before recording anything, so the same
+ // id sends it the old way, visible in the group (2026-10-24: the owner found it confusing in the project chat).
+ await send(true).catch(error => {
+ if (error instanceof SuperTabHostError && error.code === 'VALIDATION_ERROR' && error.message.includes('"agentOnly"')) return send(false)
+ throw error
})
} catch (error) {
// The notice was sent, but its record was lost (a crash, a restart, another daemon) and its group has changed since:
@@ -940,6 +946,8 @@ export class SuperTabHost {
? `In reply to message ${message.replyTo}. Read it before interpreting the answer: ${command} message ${shellQuote(group)} ${shellQuote(message.replyTo)}\n\n`
: ''
const source = object(message.source)
+ // A notice for this agent alone (a skill update): nobody else sees it, so nothing invites a reply in the conversation.
+ if (source.kind === 'agent-only') return String(message.text)
const native = source.kind === 'native'
? `This is an observed native ${String(source.phase)} in ${String(object(message.author).name ?? 'an agent')}’s terminal, opened by ${String(object(source.operator).name ?? 'a collaborator')}. The input already reached that agent. Keep the shared work coordinated; do not replay the same instruction.\n\n`
: ''