mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 04:11:35 +00:00
lineage-sidebar's #121148/#121088 steps never compacted (/compress was refused as would_grow on a tiny transcript), so they could not fail. lineage-rotation drives real auto-compaction with compression.in_place: false (state.db-verified sealed parent + continuation) and asserts one sidebar row per lineage after rotation, reload and cold relaunch; the live nested-branch shape is KNOWN #121148. lineage-compaction-prompt compacts inside an acknowledged redirect turn so the refresh passes through preserveLocalPendingTurnMessages; the duplicate prompt is KNOWN #121088. known.ts: expectNoSymptom marks a test expected-failing at run time only on the bug's own assertion (a fix merging first stays green). lineage-sidebar keeps the branch/switch scenario, drops the #121096 claim and now checks the in-page duplicate sampler.
182 lines
6.5 KiB
TypeScript
182 lines
6.5 KiB
TypeScript
/**
|
|
* Session lineage and sidebar integrity for branches. One real Electron app +
|
|
* one real `hermes serve`; only the LLM is faked.
|
|
*
|
|
* - a branch child is born with a title (#121062) and is a sidebar row of
|
|
* its own;
|
|
* - switching between the branch and its parent (3 round trips, then a
|
|
* reload) never renders the other session's turns or duplicates a part.
|
|
*
|
|
* Compaction lineages live in lineage-rotation.spec.ts (#121148) and
|
|
* lineage-compaction-prompt.spec.ts (#121088). The #121096 mechanism
|
|
* (index-keyed response-group children) is NOT reached by this switching
|
|
* scenario — see the PR's NOT COVERED list.
|
|
*/
|
|
|
|
import { expect, type Page, test } from '@playwright/test'
|
|
|
|
import {
|
|
coreAppEnv,
|
|
createCoreSandbox,
|
|
currentSessionId,
|
|
launchCoreApp,
|
|
recordWebSockets,
|
|
renderedTranscript,
|
|
send,
|
|
storedSessionForMarker,
|
|
waitForInteractive,
|
|
writeProviderHome
|
|
} from './harness'
|
|
import { installDuplicateSampler } from './oracle'
|
|
import { startScriptedProvider } from './provider'
|
|
import { sessionRows } from './remote-helpers'
|
|
|
|
const nonce = Math.random()
|
|
.toString(36)
|
|
.slice(2, 8)
|
|
.replace(/[^a-z0-9]/g, 'x')
|
|
.padEnd(4, 'q')
|
|
|
|
const U = (n: number) => `U${n}-${nonce}`
|
|
const A = (n: number) => `A${n}-${nonce}`
|
|
|
|
function viewport(page: Page) {
|
|
return page.locator('[data-slot="aui_thread-viewport"]').filter({ visible: true }).first()
|
|
}
|
|
|
|
/** Visible sidebar session rows (rows own a [data-row-actions] cluster; chat bubbles do not). */
|
|
function sidebarRows(page: Page) {
|
|
const row = '*:has(> [data-row-actions])'
|
|
|
|
return page.locator(`${row}:not(${row} *)`).filter({ visible: true })
|
|
}
|
|
|
|
/** Markers of every user bubble, in order, and how often each assistant marker renders. */
|
|
async function renderedMarkers(page: Page): Promise<{ users: string[]; assistants: string[] }> {
|
|
const { bubbles } = await renderedTranscript(page)
|
|
|
|
const pick = (role: string, re: RegExp) => bubbles.filter(b => b.role === role).flatMap(b => b.text.match(re) ?? [])
|
|
|
|
return {
|
|
users: pick('user', new RegExp(`\\bU\\d+-${nonce}\\b`, 'g')),
|
|
assistants: pick('assistant', new RegExp(`\\bA\\d+-${nonce}\\b`, 'g'))
|
|
}
|
|
}
|
|
|
|
async function settled(page: Page) {
|
|
await expect
|
|
.poll(() => page.locator('[data-slot="composer-root"] button[aria-label="Stop"]').count(), {
|
|
timeout: 60_000,
|
|
message: 'turn settled'
|
|
})
|
|
.toBe(0)
|
|
}
|
|
|
|
async function openSession(page: Page, sessionId: string, mustShow: string) {
|
|
await page.evaluate(id => {
|
|
window.location.hash = `#/${encodeURIComponent(id)}`
|
|
}, sessionId)
|
|
await expect.poll(() => currentSessionId(page)).toBe(sessionId)
|
|
await expect(viewport(page)).toContainText(mustShow, { timeout: 60_000 })
|
|
}
|
|
|
|
test('lineage: a branch child is its own titled row and switching never leaks turns', async () => {
|
|
const provider = await startScriptedProvider()
|
|
const sandbox = createCoreSandbox('lineage')
|
|
writeProviderHome(sandbox.hermesHome, provider.url)
|
|
const { app, page } = await launchCoreApp(coreAppEnv(sandbox))
|
|
const ws = recordWebSockets(page)
|
|
|
|
const finished = (marker: string) =>
|
|
expect
|
|
.poll(() => provider.completions.some(c => c.marker === marker && c.finished), {
|
|
timeout: 120_000,
|
|
message: `provider finished ${marker}`
|
|
})
|
|
.toBe(true)
|
|
|
|
const turn = async (n: number, words: string) => {
|
|
provider.script(U(n), [{ text: [`${A(n)} `, ...words.split(' ').map(w => `${w} `)] }])
|
|
await send(page, `${U(n)} ${words}`, 'Enter', ws)
|
|
await finished(U(n))
|
|
await expect(viewport(page)).toContainText(A(n))
|
|
await settled(page)
|
|
}
|
|
|
|
try {
|
|
await waitForInteractive(app, page)
|
|
await installDuplicateSampler(page)
|
|
|
|
await test.step('a parent conversation with two turns', async () => {
|
|
await turn(1, 'first question here')
|
|
await turn(2, 'second question here')
|
|
await expect.poll(() => sidebarRows(page).count()).toBe(1)
|
|
})
|
|
|
|
let branchId = ''
|
|
let parentId = ''
|
|
|
|
await test.step('a branch child is titled and is its own row (#121062)', async () => {
|
|
parentId = await currentSessionId(page)
|
|
const before = new Set(sessionRows(sandbox).map(r => r.id))
|
|
const row = sidebarRows(page).first()
|
|
await row.click({ button: 'right' })
|
|
await page
|
|
.getByRole('menuitem', { name: /^branch/i })
|
|
.first()
|
|
.click()
|
|
await expect
|
|
.poll(() => sessionRows(sandbox).filter(r => !before.has(r.id)).length, {
|
|
timeout: 60_000,
|
|
message: 'the branch created a session row'
|
|
})
|
|
.toBeGreaterThan(0)
|
|
await expect.poll(() => currentSessionId(page), { timeout: 60_000 }).not.toBe(parentId)
|
|
await turn(5, 'only on the branch')
|
|
branchId = storedSessionForMarker(sandbox, 'default', U(5)) ?? ''
|
|
expect(branchId).not.toBe('')
|
|
expect(before.has(branchId), 'U5 landed in a NEW session').toBe(false)
|
|
|
|
await expect
|
|
.poll(() => sessionRows(sandbox).find(r => r.id === branchId)?.title ?? null, {
|
|
timeout: 30_000,
|
|
message: 'branch child has a title'
|
|
})
|
|
.not.toBeNull()
|
|
await expect.poll(() => sidebarRows(page).count(), { timeout: 30_000 }).toBe(2)
|
|
})
|
|
|
|
await test.step("switching branch ↔ parent never renders the other session's turn or a duplicate part", async () => {
|
|
for (let round = 0; round < 3; round++) {
|
|
await openSession(page, parentId, A(2))
|
|
const parent = await renderedMarkers(page)
|
|
expect(parent.users, `round ${round}: parent never shows the branch turn`).not.toContain(U(5))
|
|
expect(new Set(parent.assistants).size, `round ${round}: parent assistant parts unique`).toBe(
|
|
parent.assistants.length
|
|
)
|
|
|
|
await openSession(page, branchId, A(5))
|
|
const branch = await renderedMarkers(page)
|
|
expect(
|
|
branch.users.filter(m => m === U(5)),
|
|
`round ${round}: branch turn once`
|
|
).toHaveLength(1)
|
|
expect(new Set(branch.assistants).size, `round ${round}: branch assistant parts unique`).toBe(
|
|
branch.assistants.length
|
|
)
|
|
}
|
|
|
|
// Every frame sampled across the switches (transient duplicates included).
|
|
const violations = await page.evaluate(() => (window as any).__coreSampler?.violations ?? [])
|
|
expect(violations, 'no marker rendered twice in any sampled frame').toEqual([])
|
|
|
|
await page.reload()
|
|
await waitForInteractive(app, page)
|
|
await expect.poll(() => sidebarRows(page).count(), { timeout: 30_000 }).toBe(2)
|
|
})
|
|
} finally {
|
|
await app.close().catch(() => undefined)
|
|
await provider.close()
|
|
sandbox.cleanup()
|
|
}
|
|
})
|