🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
test(ruflo-swarm): engine-kit tests for register and pane over a real ruflo run
ruv77e526253706
diff --git a/plugins/ruflo-swarm/tests/fixtures/inputs.ts b/plugins/ruflo-swarm/tests/fixtures/inputs.tsnew file mode 100644index 0000000000..3e6d202c91--- /dev/null+++ b/plugins/ruflo-swarm/tests/fixtures/inputs.ts@@ -0,0 +1,47 @@+import type { AgentSpawnInput, RenderInput, SessionStartInput } from 'claude-code'++export const PLUGIN = 'ruflo-swarm'+export const CWD = '/work'++export const SESSION: SessionStartInput = { surface: 'terminal', isInteractive: true, cwd: CWD }++export const HINT: RenderInput<'PromptHint'> = {+ component: 'PromptHint',+ surface: 'terminal',+ requestId: 'hint',+ viewport: { columns: 180, rows: 48, isFullscreen: true },+ props: { isDraft: false, isWorking: false, hint: '' },+}++export const MAIN_SCREEN_HINT: RenderInput<'PromptHint'> = { ...HINT, viewport: { columns: 180, rows: 48, isFullscreen: false } }++/** The swarm pane as the engine asks for it, docked, 72 columns of body and 44 rows. */+export const PANE: RenderInput<'Pane'> = {+ component: 'Pane',+ surface: 'terminal',+ requestId: 'ruflo-swarm',+ viewport: { columns: 180, rows: 48, isFullscreen: true },+ props: { title: 'Swarm', isFocused: false, bodyColumns: 73, placement: 'dock', scroll: { offset: 0, bodyRows: 44 }, view: {} },+}++export const paneAt = (bodyColumns: number, bodyRows = 44): RenderInput<'Pane'> => ({ ...PANE, props: { ...PANE.props, bodyColumns, scroll: { offset: 0, bodyRows } } })++export const command = (name: string, args = '') => ({+ command: name,+ args,+ origin: { kind: 'composer' as const },+ presentation: { isFullscreen: true, columns: 180 },+})++/** An Agent tool's spawn as the engine raises it, with what the caller asked for. */+export const spawn = (subagentType: string, prompt: string, name?: string): AgentSpawnInput => ({+ tool_use_id: `toolu_${subagentType.replace(/\W/g, '')}`,+ prompt,+ description: prompt.slice(0, 30),+ subagentType,+ provider: { plugin: 'engine', tier: 'core' },+ parentModel: 'claude-opus-5-5',+ background: true,+ fork: false,+ ...(name !== undefined && { name }),+})diff --git a/plugins/ruflo-swarm/tests/fixtures/ruflo-run.ts b/plugins/ruflo-swarm/tests/fixtures/ruflo-run.tsnew file mode 100644index 0000000000..61ee342ad1--- /dev/null+++ b/plugins/ruflo-swarm/tests/fixtures/ruflo-run.ts@@ -0,0 +1,180 @@+/**+ * The files ruflo 3.49.0 wrote in a real run (swarm init, three agent spawns, two tasks, a claim, an assignment,+ * hive-mind init and a consensus proposal), captured from disk. The hive token is replaced by a sentinel the tests+ * assert never reaches a drawing, a command's text or a log.+ */+export const HIVE_TOKEN = 'HIVE-TOKEN-SENTINEL-must-never-render'++export const RUFLO_RUN: Record<string, string> = {+ ".claude-flow/swarm/swarm-state.json": JSON.stringify({+ "swarms": {+ "swarm-1790888806724-u3ktj4": {+ "swarmId": "swarm-1790888806724-u3ktj4",+ "topology": "hierarchical",+ "maxAgents": 8,+ "status": "running",+ "agents": [+ "agent-1790888815793-6ju96w",+ "agent-1790888816288-z5xsn6",+ "agent-1790888816793-b2xzp7"+ ],+ "tasks": [],+ "config": {+ "topology": "hierarchical",+ "maxAgents": 8,+ "strategy": "specialized",+ "communicationProtocol": "message-bus",+ "autoScaling": true,+ "consensusMechanism": "majority"+ },+ "createdAt": "2026-10-01T21:06:46.724Z",+ "updatedAt": "2026-10-01T21:06:46.724Z"+ }+ },+ "version": "3.0.0"+ }),+ ".swarm/state.json": JSON.stringify({+ "id": "swarm-1790888806724-u3ktj4",+ "topology": "hierarchical",+ "maxAgents": 8,+ "strategy": "specialized",+ "v3Mode": false,+ "permissions": null,+ "initializedAt": "2026-10-01T21:06:46.724Z",+ "status": "ready"+ }),+ ".claude-flow/agents/store.json": JSON.stringify({+ "agents": {+ "agent-1790888815793-6ju96w": {+ "agentId": "agent-1790888815793-6ju96w",+ "agentType": "coder",+ "status": "busy",+ "health": 1,+ "taskCount": 0,+ "config": {+ "provider": "anthropic",+ "timeout": 300,+ "autoTools": true+ },+ "createdAt": "2026-10-01T21:06:55.793Z",+ "model": "sonnet",+ "modelRoutedBy": "default",+ "currentTask": "task-1790888817265-vatniv"+ },+ "agent-1790888816288-z5xsn6": {+ "agentId": "agent-1790888816288-z5xsn6",+ "agentType": "tester",+ "status": "idle",+ "health": 1,+ "taskCount": 0,+ "config": {+ "provider": "anthropic",+ "timeout": 300,+ "autoTools": true+ },+ "createdAt": "2026-10-01T21:06:56.288Z",+ "model": "sonnet",+ "modelRoutedBy": "default"+ },+ "agent-1790888816793-b2xzp7": {+ "agentId": "agent-1790888816793-b2xzp7",+ "agentType": "reviewer",+ "status": "idle",+ "health": 1,+ "taskCount": 0,+ "config": {+ "provider": "anthropic",+ "timeout": 300,+ "autoTools": true+ },+ "createdAt": "2026-10-01T21:06:56.793Z",+ "model": "sonnet",+ "modelRoutedBy": "default"+ }+ },+ "version": "3.0.0"+ }),+ ".claude-flow/tasks/store.json": JSON.stringify({+ "tasks": {+ "task-1790888817265-vatniv": {+ "taskId": "task-1790888817265-vatniv",+ "type": "implementation",+ "description": "Build login form",+ "priority": "normal",+ "status": "in_progress",+ "progress": 0,+ "assignedTo": [+ "agent-1790888815793-6ju96w"+ ],+ "tags": [],+ "createdAt": "2026-10-01T21:06:57.265Z",+ "startedAt": "2026-10-01T21:07:39.789Z",+ "completedAt": null+ },+ "task-1790888817757-h3rps7": {+ "taskId": "task-1790888817757-h3rps7",+ "type": "testing",+ "description": "Write login tests",+ "priority": "normal",+ "status": "pending",+ "progress": 0,+ "assignedTo": [],+ "tags": [],+ "createdAt": "2026-10-01T21:06:57.757Z",+ "startedAt": null,+ "completedAt": null+ }+ },+ "version": "3.0.0"+ }),+ ".claude-flow/claims/claims.json": JSON.stringify({+ "claims": {+ "task-1790888817265-vatniv": {+ "issueId": "task-1790888817265-vatniv",+ "claimant": {+ "type": "agent",+ "agentId": "agent-1790888815793-6ju96w",+ "agentType": "coder"+ },+ "claimedAt": "2026-10-01T21:07:39.332Z",+ "status": "active",+ "statusChangedAt": "2026-10-01T21:07:39.332Z",+ "progress": 0+ }+ },+ "stealable": {},+ "contests": {}+ }),+ ".claude-flow/hive-mind/state.json": JSON.stringify({+ "initialized": true,+ "topology": "hierarchical",+ "workers": [],+ "consensus": {+ "pending": [+ {+ "proposalId": "proposal-1790888860262-55jkcl",+ "type": "design",+ "value": "use-jwt",+ "proposedBy": "system",+ "proposedAt": "2026-10-01T21:07:40.262Z",+ "votes": {},+ "status": "pending",+ "strategy": "raft",+ "term": 1,+ "timeoutAt": "2026-10-01T21:08:10.262Z"+ }+ ],+ "history": []+ },+ "sharedMemory": {},+ "createdAt": "2026-10-01T21:06:58.222Z",+ "updatedAt": "2026-10-01T21:07:40.262Z",+ "consensusStrategy": "byzantine",+ "queen": {+ "agentId": "queen-1790888818222",+ "electedAt": "2026-10-01T21:06:58.222Z",+ "term": 1+ },+ "hiveToken": "HIVE-TOKEN-SENTINEL-must-never-render"+ }),+}diff --git a/plugins/ruflo-swarm/tests/fixtures/world.ts b/plugins/ruflo-swarm/tests/fixtures/world.tsnew file mode 100644index 0000000000..57e7efc382--- /dev/null+++ b/plugins/ruflo-swarm/tests/fixtures/world.ts@@ -0,0 +1,171 @@+import type { On, RenderElement, RenderNode } from 'claude-code'++import { CWD } from './inputs'++/** One `$.process.run` the mod made, and what the world answers it with. */+export type Run = { argv: string[]; timeoutMs?: number }+export type Responder = (argv: readonly string[]) => { exitCode: number; stdout: string; stderr: string; write?: Record<string, string> }++/**+ * The world beneath the mod, in memory: a file tree `$.fs` answers from, a process table `$.process.run` answers+ * from, and a record of everything the mod asked the engine to do.+ */+export type World = {+ files: Map<string, string>+ runs: Run[]+ opened: string[]+ closed: string[]+ toasts: string[]+ logs: string[]+ fills: string[]+ commands: string[]+ stored: Map<string, unknown>+ invalidations: number+ respond: Responder+ /** Writes a file as ruflo's CLI would, moving its mtime on. */+ put: (path: string, text: string) => void+}++const relOf = (path: string) => (path.startsWith(`${CWD}/`) ? path.slice(CWD.length + 1) : path)++export const exitOk = (stdout = ''): ReturnType<Responder> => ({ exitCode: 0, stdout, stderr: '' })++/** Seats the in-memory world beneath the plugin. `usage` is what `$.session.usage()` answers; null refuses it. */+export function worldOf(on: On, files: Readonly<Record<string, string>>, usage: unknown = { context: { tokens: 68_000, window: 200_000, percent: 34 }, rateLimits: [], cost: { usd: 0.4213 } }): World {+ let tick = 1_000+ const mtimes = new Map<string, number>(Object.keys(files).map(path => [path, tick]))++ const world: World = {+ files: new Map(Object.entries(files)),+ runs: [],+ opened: [],+ closed: [],+ toasts: [],+ logs: [],+ fills: [],+ commands: [],+ stored: new Map(),+ invalidations: 0,+ respond: () => exitOk(),+ put: (path, text) => {+ tick += 1_000+ world.files.set(path, text)+ mtimes.set(path, tick)+ },+ }++ on('fs.read', ($, e) => {+ const text = world.files.get(relOf(e.path))++ return text === undefined ? { deny: `ENOENT: ${e.path}` } : { value: text }+ })++ on('fs.stat', ($, e) => {+ const text = world.files.get(relOf(e.path))++ return text === undefined ? { deny: `ENOENT: ${e.path}` } : { value: { kind: 'file' as const, size: text.length, mtimeMs: mtimes.get(relOf(e.path)) ?? 0, isLink: false } }+ })++ on('process.run', ($, e) => {+ world.runs.push({ argv: [...e.argv], ...(e.init?.timeoutMs !== undefined && { timeoutMs: e.init.timeoutMs }) })++ const answer = world.respond(e.argv)++ for (const [path, text] of Object.entries(answer.write ?? {})) {+ world.put(path, text)+ }++ return { value: { exitCode: answer.exitCode, stdout: answer.stdout, stderr: answer.stderr } }+ })++ on('session.usage', () => (usage === null ? { deny: 'usage refused' } : { value: usage as never }))+ on('agent.list', () => ({ value: [] }))+ on('store.get', ($, e) => ({ value: world.stored.get(e.key) }))+ on('store.set', ($, e) => {+ world.stored.set(e.key, e.value)++ return { value: undefined }+ })++ on('command.register', ($, e) => {+ world.commands.push(e.name)++ return { value: { command: e.name } }+ })++ on('ui.open', ($, e) => {+ world.opened.push(e.id)++ return { value: { isPlaced: true } } as never+ })++ on('ui.close', ($, e) => {+ world.closed.push(e.id)++ return { value: undefined }+ })++ on('ui.toast', ($, e) => {+ world.toasts.push(e.text)++ return { value: undefined }+ })++ on('ui.log', ($, e) => {+ world.logs.push(e.text)++ return { value: undefined }+ })++ on('ui.invalidate', () => {+ world.invalidations += 1++ return { value: undefined }+ })++ on('prompt.fill', ($, e) => {+ world.fills.push(e.text)++ return { isFilled: true }+ })++ on('session.start', ($, e) => ({ cwd: e.cwd }))+ on('turn.start', ($, e) => ({ turnId: e.turnId }))+ on('turn.complete', ($, e) => ({ text: e.answer }))++ return world+}++/** Every string a drawn tree holds, button labels included, in drawing order. */+export function stringsOf(node: RenderNode | RenderElement | null | undefined): string[] {+ if (node === null || node === undefined || typeof node === 'boolean') {+ return []+ }++ if (typeof node === 'string' || typeof node === 'number') {+ return [String(node)]+ }++ const props = (node as { props?: Record<string, unknown> }).props+ const own = node.type === 'Button' && typeof props?.label === 'string' ? [props.label] : []+ const children = (node as { children?: readonly RenderNode[] }).children ?? []++ return [...own, ...children.flatMap(child => stringsOf(child))]+}++export const textOf = (node: RenderNode | RenderElement | null | undefined): string => stringsOf(node).join('')++/** Every element of `type` in a drawn tree. */+export function elementsOf(node: RenderNode | RenderElement | null | undefined, type: string): RenderElement[] {+ if (node === null || node === undefined || typeof node !== 'object') {+ return []+ }++ const children = (node as { children?: readonly RenderNode[] }).children ?? []++ return [...(node.type === type ? [node as RenderElement] : []), ...children.flatMap(child => elementsOf(child, type))]+}++/** The `key`s of every Button drawn, in order. */+export const buttonKeysOf = (node: RenderNode | RenderElement | null | undefined): string[] =>+ elementsOf(node, 'Button').map(button => String((button as { key?: unknown; props?: { key?: unknown } }).key ?? (button as { props?: { key?: unknown } }).props?.key ?? ''))diff --git a/plugins/ruflo-swarm/tests/pane.test.ts b/plugins/ruflo-swarm/tests/pane.test.tsnew file mode 100644index 0000000000..1722e38079--- /dev/null+++ b/plugins/ruflo-swarm/tests/pane.test.ts@@ -0,0 +1,129 @@+import type { RenderElement } from 'claude-code'+import { describe, expect, mock, test } from 'claude-code/testing'++import { HIVE_TOKEN, RUFLO_RUN } from './fixtures/ruflo-run'+import { command, PANE, paneAt, PLUGIN, SESSION, spawn } from './fixtures/inputs'+import { buttonKeysOf, elementsOf, textOf, worldOf } from './fixtures/world'++const tileOf = (tree: RenderElement, label: string) =>+ elementsOf(tree, 'Text').find(node => textOf(node).includes(label) && (node as { props?: { inverse?: boolean } }).props?.inverse !== undefined) as+ | { props: { inverse?: boolean; color?: string } }+ | undefined++describe('pane', () => {+ test('draws the swarm: tiles by state, the leader, the board, consensus, topology, router and usage', async ($, on) => {+ worldOf(on, RUFLO_RUN)+ mock.clock(on)+ await $.session.start(SESSION)+ await $.command.run(command('ruflo-swarm-pane'))++ const tree = await $.ui.render(PANE)+ const text = textOf(tree)++ expect(text).toContain('swarm …4-u3ktj4 · hierarchical · running')+ expect(text).toContain('★ queen')+ for (const role of ['coder', 'tester', 'reviewer', 'claude (main)']) {+ expect(text).toContain(role)+ }+ expect(text).toContain('pending 1 · claimed 1 · done 0')+ expect(text).toContain('Build login form → coder')+ expect(text).toContain('Write login tests → unassigned')+ expect(text).toContain('design (raft) for 0 · against 0')+ expect(text).toContain('├─ coder')+ expect(text).toContain('router: no pick seen this session')+ expect(text).toContain('cost $0.421 · context 68k/200k (34%)')+ expect(text).not.toContain(HIVE_TOKEN)+ expect(buttonKeysOf(tree)).toEqual(expect.arrayContaining(['hide', 'prev', 'next', 'logs', 'task-prev', 'task-next', 'offer', 'reroute', 'vote-yes', 'vote-no']))+ })++ test('a figure the engine does not give is n/a, never zero', async ($, on) => {+ worldOf(on, RUFLO_RUN, { context: { window: 200_000 }, rateLimits: [] })+ mock.clock(on)+ await $.session.start(SESSION)++ expect(textOf(await $.ui.render(PANE))).toContain('cost n/a · context n/a/200k')+ })++ test('a tile lights blue while its agent reads and yellow while it writes, then fades', async ($, on) => {+ worldOf(on, RUFLO_RUN)+ mock.clock(on)+ on('tool.call', () => ({ result: 'ok', text: 'ok' }))+ on('agent.spawn', () => ({ model: 'haiku', agentId: 'agent-cc-1' }))+ await $.session.start(SESSION)+ await $.command.run(command('ruflo-swarm-pane'))++ await $.agent.spawn(spawn('ruflo-swarm:coordinator', 'write the tests', 'tester-cc'))+ await $.tool.call({ tool: 'Read', file_path: '/work/src/a.ts', agentId: 'agent-cc-1' } as never)++ const reading = tileOf(await $.ui.render(PANE), 'tester-cc')++ expect(reading?.props.inverse).toBe(true)+ expect(reading?.props.color).toBe('suggestion')++ await $.tool.call({ tool: 'Edit', file_path: '/work/src/a.ts', old_string: 'a', new_string: 'b', agentId: 'agent-cc-1' } as never)+ expect(tileOf(await $.ui.render(PANE), 'tester-cc')?.props.color).toBe('warning')+ })++ test('Claude Code subagents join as members by their type, and a finished one reads as done', async ($, on) => {+ worldOf(on, RUFLO_RUN)+ mock.clock(on)+ on('agent.spawn', () => ({ model: 'haiku', agentId: 'agent-cc-2' }))+ await $.session.start(SESSION)++ await $.agent.spawn(spawn('ruflo-core:reviewer', 'review it'))+ expect(textOf(await $.ui.render(PANE))).toContain('reviewer')++ await $.turn.complete({ answer: 'ok', durationMs: 5, isAborted: false, turnId: 't9', reason: 'answer', agentId: 'agent-cc-2' } as never)++ const status = (await $.command.run(command('ruflo-swarm-status'))).text ?? ''++ expect(status).toContain('· reviewer (claude) completed')+ })++ test('narrower than 44 columns the pane is a list, and the terminal accepts it at every width', async ($, on) => {+ worldOf(on, RUFLO_RUN)+ mock.clock(on)+ on('ui.render', () => ({ type: 'Text', children: [''] }))+ await $.session.start(SESSION)+ await $.command.run(command('ruflo-swarm-pane'))++ const narrow = await $.ui.render(paneAt(30, 30))++ expect(textOf(narrow)).toContain('tasks 1 pending · 1 claimed')+ expect(buttonKeysOf(narrow)).not.toContain('offer')++ for (const [columns, rows] of [[24, 12], [30, 30], [48, 40], [73, 44], [120, 8], [160, 60]] as const) {+ const mounted = await $.ui.mount({ ...paneAt(columns, rows), plugin: PLUGIN })++ expect(mounted.surface).toBe('terminal')+ await mounted.unmount()+ }+ })++ test('a short body sheds the lower sections first and keeps the tiles and selection', async ($, on) => {+ worldOf(on, RUFLO_RUN)+ mock.clock(on)+ await $.session.start(SESSION)++ const text = textOf(await $.ui.render(paneAt(73, 8)))++ expect(text).toContain('coder')+ expect(text).not.toContain('Topology')+ })++ test('draws in theme colours only, never ANSI names that fade on a light background', async ($, on) => {+ worldOf(on, RUFLO_RUN)+ mock.clock(on)+ await $.session.start(SESSION)++ const colors = new Set(elementsOf(await $.ui.render(PANE), 'Text').flatMap(node => {+ const color = (node as { props?: { color?: string } }).props?.color++ return color === undefined ? [] : [color]+ }))++ for (const color of colors) {+ expect(['suggestion', 'success', 'error', 'warning', 'claude']).toContain(color)+ }+ })+})diff --git a/plugins/ruflo-swarm/tests/register.test.ts b/plugins/ruflo-swarm/tests/register.test.tsnew file mode 100644index 0000000000..c00a5d1fa4--- /dev/null+++ b/plugins/ruflo-swarm/tests/register.test.ts@@ -0,0 +1,110 @@+import { describe, expect, mock, test } from 'claude-code/testing'++import { HIVE_TOKEN, RUFLO_RUN } from './fixtures/ruflo-run'+import { command, HINT, MAIN_SCREEN_HINT, PANE, PLUGIN, SESSION } from './fixtures/inputs'+import { buttonKeysOf, textOf, worldOf } from './fixtures/world'++describe('register', () => {+ test('the start registers the five commands and opens nothing by itself', async ($, on) => {+ const world = worldOf(on, RUFLO_RUN)++ mock.clock(on)+ await $.session.start(SESSION)++ expect(world.commands.sort()).toEqual(['ruflo-swarm-claims', 'ruflo-swarm-consensus', 'ruflo-swarm-pane', 'ruflo-swarm-status', 'ruflo-swarm-topology'])+ expect(world.opened).toEqual([])+ })++ test('with a swarm on disk the pane opens once the fullscreen hint draws; on the main screen it waits', async ($, on) => {+ const world = worldOf(on, RUFLO_RUN)+ const clock = mock.clock(on)++ on('ui.render', () => ({ type: 'Text', children: [''] }))+ await $.session.start(SESSION)+ await $.ui.render(MAIN_SCREEN_HINT)+ await clock.advance(200)+ expect(world.opened, 'not fullscreen: nothing opens unasked').toEqual([])++ await $.ui.render(HINT)+ await clock.advance(200)+ await $.ui.render(HINT)+ await clock.advance(200)+ expect(world.opened).toEqual([PLUGIN])+ })++ test('with no swarm on disk nothing opens, and the pane says how to start one', async ($, on) => {+ const world = worldOf(on, { 'README.md': 'x' })+ const clock = mock.clock(on)++ on('ui.render', () => ({ type: 'Text', children: [''] }))+ await $.session.start(SESSION)+ await $.ui.render(HINT)+ await clock.advance(200)+ expect(world.opened).toEqual([])++ const tree = await $.ui.render(PANE)++ expect(textOf(tree)).toContain('No ruflo swarm on disk in this folder.')+ expect(textOf(tree)).toContain('/ruflo-swarm:swarm init')+ expect(buttonKeysOf(tree)).toEqual(['hide', 'fill'])++ await $.ui.press({ plugin: PLUGIN, key: 'fill' })+ expect(world.fills).toEqual(['/ruflo-swarm:swarm init'])+ })++ test('/ruflo-swarm-pane toggles the pane and says which', async ($, on) => {+ const world = worldOf(on, RUFLO_RUN)++ mock.clock(on)+ await $.session.start(SESSION)++ expect(await $.command.run(command('ruflo-swarm-pane'))).toEqual({ text: 'Swarm pane shown' })+ expect(await $.command.run(command('ruflo-swarm-pane'))).toEqual({ text: 'Swarm pane hidden' })+ expect(world.opened).toEqual([PLUGIN])+ expect(world.closed).toEqual([PLUGIN])+ })++ test('the markdown /ruflo-swarm:watch still runs, and the mod opens the pane beside it', async ($, on) => {+ const world = worldOf(on, RUFLO_RUN)+ const ran: string[] = []++ mock.clock(on)+ on('command.run', ($, e) => {+ ran.push(e.command)++ return { text: 'markdown command ran' }+ })+ await $.session.start(SESSION)++ expect(await $.command.run(command('ruflo-swarm:watch'))).toEqual({ text: 'markdown command ran' })+ expect(ran).toEqual(['ruflo-swarm:watch'])+ expect(world.opened).toEqual([PLUGIN])+ })++ test('the status, topology, claims and consensus commands report what is on disk, never the hive token', async ($, on) => {+ worldOf(on, RUFLO_RUN)+ mock.clock(on)+ await $.session.start(SESSION)++ const status = (await $.command.run(command('ruflo-swarm-status'))).text ?? ''+ const json = (await $.command.run(command('ruflo-swarm-status', 'json'))).text ?? ''+ const topology = (await $.command.run(command('ruflo-swarm-topology'))).text ?? ''+ const claims = (await $.command.run(command('ruflo-swarm-claims'))).text ?? ''+ const consensus = (await $.command.run(command('ruflo-swarm-consensus'))).text ?? ''++ expect(status).toContain('swarm …4-u3ktj4 · hierarchical · running')+ expect(status).toContain('· coder (ruflo) busy')+ expect(status).toContain('tasks: 1 pending, 1 claimed, 0 done')+ expect(status).toContain('router: no pick seen this session')+ expect(status).toContain('cost $0.421 · context 68k/200k (34%)')+ expect(topology).toContain('hierarchical (strategy specialized, max 8 agents, hive consensus byzantine)')+ expect(topology).toContain('★ queen')+ expect(topology).toContain('├─ coder')+ expect(claims).toContain('task-1790888817265-vatniv: active by agent coder agent-1790888815793-6ju96w')+ expect(consensus).toContain('open proposal-1790888860262-55jkcl design (raft): for 0, against 0')++ for (const text of [status, json, topology, claims, consensus]) {+ expect(text).not.toContain(HIVE_TOKEN)+ }+ })+})