Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

Load older conversations continuously with bounded transcript reads (#1320)

Regan Bell22eed5f3346f
diff --git a/docs/screenshots/history-pagination.png b/docs/screenshots/history-pagination.png
new file mode 100644
index 000000000..35dc7185e
Binary files /dev/null and b/docs/screenshots/history-pagination.png differ
diff --git a/plugins/web-ui/src/transcript-viewport.ts b/plugins/web-ui/src/transcript-viewport.ts
index cf88b9e9f..5ed97456d 100644
--- a/plugins/web-ui/src/transcript-viewport.ts
+++ b/plugins/web-ui/src/transcript-viewport.ts
@@ -123,6 +123,7 @@ export function createTranscriptViewport() {
function onScroll(): void {
if (!scroller || contentUpdates.size > 0) return;
+ const movingUp = scroller.scrollTop < lastTop;
const atBottom = scroller.scrollHeight - scroller.clientHeight - scroller.scrollTop <= 1;
const reachedPreviousBottom =
scroller.scrollTop > lastTop &&
@@ -134,6 +135,15 @@ export function createTranscriptViewport() {
lastTop = scroller.scrollTop;
measureBottom();
syncSticky();
+ if (movingUp) loadEarlier();
+ }
+
+ function loadEarlier(): void {
+ if (!scroller || scroller.scrollTop > 400) return;
+ const button = scroller.querySelector<HTMLButtonElement>(".earlier-messages-btn:not(:disabled)");
+ if (!button) return;
+ cancelFollow();
+ button.click();
}
function measureBottom(): void {
@@ -172,6 +182,7 @@ export function createTranscriptViewport() {
function onWheel(event: WheelEvent): void {
if (!scroller) return;
+ if (event.deltaY < 0) loadEarlier();
if (event.deltaY < 0 && scroller.scrollTop > 0) cancelFollow();
if (event.deltaY > 0) {
clearInput();
diff --git a/plugins/web-ui/test/transcript-viewport.test.ts b/plugins/web-ui/test/transcript-viewport.test.ts
index 700c474e4..b95ae2a73 100644
--- a/plugins/web-ui/test/transcript-viewport.test.ts
+++ b/plugins/web-ui/test/transcript-viewport.test.ts
@@ -169,6 +169,65 @@ function fixture() {
};
}
+test("scrolling toward earlier messages loads before reaching the top and pauses following", () => {
+ const f = fixture();
+ try {
+ const button = f.s.ownerDocument.createElement("button");
+ button.className = "earlier-messages-btn";
+ f.s.querySelector(".message-stack")!.prepend(button);
+ let loads = 0;
+ button.onclick = () => {
+ loads++;
+ button.disabled = true;
+ };
+ f.viewport.sync(f.s);
+ assert.equal(loads, 0);
+ f.scroll(500);
+ assert.equal(loads, 0);
+ f.scroll(350);
+ assert.equal(loads, 1);
+ f.scroll(100);
+ f.wheelUp();
+ assert.equal(loads, 1);
+ f.grow();
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 100);
+ button.disabled = false;
+ f.scroll(300);
+ assert.equal(loads, 1);
+ f.scroll(200);
+ assert.equal(loads, 2);
+ } finally {
+ f.close();
+ }
+});
+
+test("upward wheel loads history even when the transcript cannot scroll", () => {
+ const f = fixture();
+ try {
+ f.fit();
+ const button = f.s.ownerDocument.createElement("button");
+ button.className = "earlier-messages-btn";
+ f.s.querySelector(".message-stack")!.prepend(button);
+ let loads = 0;
+ button.onclick = () => {
+ loads++;
+ };
+ f.wheelUp();
+ assert.equal(loads, 1);
+ f.grow();
+ f.viewport.follow();
+ f.flush();
+ assert.equal(f.s.scrollTop, 0);
+ f.viewport.dispose();
+ f.wheelUp();
+ assert.equal(loads, 1);
+ } finally {
+ f.close();
+ }
+});
+
test("a bottom-pinned stream follows growth instantly and coalesces frames", () => {
const f = fixture();
try {
diff --git a/src/api/app-sessions.ts b/src/api/app-sessions.ts
index 1917b5da5..4e2d0f9d3 100644
--- a/src/api/app-sessions.ts
+++ b/src/api/app-sessions.ts
@@ -35,8 +35,7 @@ interface TranscriptWindow {
}
function tailWindowLimit(window?: TranscriptWindow): number | undefined {
- if (window?.tailTurns === undefined || window.sinceSeq !== undefined || window.beforeSeq !== undefined)
- return undefined;
+ if (window?.tailTurns === undefined || window.sinceSeq !== undefined) return undefined;
return Math.min(window.tailTurns * ENTRIES_PER_TURN_ESTIMATE, TAIL_WINDOW_ENTRY_CAP);
}
@@ -205,14 +204,18 @@ export function createSessionMethods(
async getSession(sessionId, window) {
const session = await deps.sessions.get(sessionId);
if (!session) return null;
- const limit = tailWindowLimit(window);
- let read = await transcripts.forRender(sessionId, limit !== undefined ? { limit } : undefined);
+ let limit = tailWindowLimit(window);
+ const [initialRead, pinRecords] = await Promise.all([
+ transcripts.forRender(sessionId, { limit, beforeSeq: window?.beforeSeq }),
+ deps.sessions.listPins(sessionId),
+ ]);
+ let read = initialRead;
let all = transcriptEntries(read.entries);
- if (limit !== undefined && read.earlier > 0 && !coversTailWindow(all, window!.tailTurns!)) {
- read = await transcripts.forRender(sessionId);
+ while (limit !== undefined && read.earlier > 0 && !coversTailWindow(all, window!.tailTurns!)) {
+ limit *= 2;
+ read = await transcripts.forRender(sessionId, { limit, beforeSeq: window?.beforeSeq });
all = transcriptEntries(read.entries);
}
- const pinRecords = await deps.sessions.listPins(sessionId);
const w = windowedTranscript(all, window);
const earlier = w.earlier + read.earlier;
const pins = await decoratedPins(pinRecords, all, (seq) => storedEntryAt(sessionId, seq));
@@ -246,14 +249,18 @@ export function createSessionMethods(
async getSessionForViewer(sessionId, principalId, window) {
const session = await sessionForViewer(sessionId, principalId);
if (!session) return null;
- const limit = tailWindowLimit(window);
- let read = await transcripts.forViewer(sessionId, principalId, limit !== undefined ? { limit } : undefined);
+ let limit = tailWindowLimit(window);
+ const [initialRead, pinRecords] = await Promise.all([
+ transcripts.forViewer(sessionId, principalId, { limit, beforeSeq: window?.beforeSeq }),
+ deps.sessions.listPins(sessionId),
+ ]);
+ let read = initialRead;
let visible = transcriptEntries(read.entries);
- if (limit !== undefined && read.earlier > 0 && !coversTailWindow(visible, window!.tailTurns!)) {
- read = await transcripts.forViewer(sessionId, principalId);
+ while (limit !== undefined && read.earlier > 0 && !coversTailWindow(visible, window!.tailTurns!)) {
+ limit *= 2;
+ read = await transcripts.forViewer(sessionId, principalId, { limit, beforeSeq: window?.beforeSeq });
visible = transcriptEntries(read.entries);
}
- const pinRecords = await deps.sessions.listPins(sessionId);
const w = windowedTranscript(visible, window);
const earlier = w.earlier + read.earlier;
const pins = await decoratedPins(pinRecords, visible, (seq) => viewerStoredEntryAt(sessionId, principalId, seq));
diff --git a/src/harness/tape-projection.ts b/src/harness/tape-projection.ts
index 0a76f3b55..5df46a5ce 100644
--- a/src/harness/tape-projection.ts
+++ b/src/harness/tape-projection.ts
@@ -407,7 +407,11 @@ interface TranscriptRead {
export interface TranscriptSource {
forRender(sessionId: string, opts?: GetEntriesOptions): Promise<TranscriptRead>;
- forViewer(sessionId: string, principalId: string, opts?: { limit?: number }): Promise<TranscriptRead>;
+ forViewer(
+ sessionId: string,
+ principalId: string,
+ opts?: { limit?: number; beforeSeq?: number },
+ ): Promise<TranscriptRead>;
}
interface ProjectedRead {
@@ -417,17 +421,24 @@ interface ProjectedRead {
}
export function createTranscriptSource(sessions: TranscriptStore): TranscriptSource {
- const projected = async (sessionId: string, limit?: number): Promise<ProjectedRead | null> => {
+ const projected = async (sessionId: string, limit?: number, beforeSeq?: number): Promise<ProjectedRead | null> => {
try {
- const latest = await sessions.latestEntrySeq(sessionId);
+ const latest = Math.min(
+ await sessions.latestEntrySeq(sessionId),
+ beforeSeq === undefined ? Infinity : beforeSeq - 1,
+ );
if (latest < 0) return { entries: [], anchored: false, base: -1 };
if (sessions.getTranscriptEntries) {
- const entries = await sessions.getTranscriptEntries(sessionId, limit === undefined ? undefined : { limit });
+ const entries = await sessions.getTranscriptEntries(sessionId, { limit, beforeSeq });
const first = limit === undefined ? 0 : Math.max(0, latest - limit + 1);
if (entries.length === latest - first + 1 && entries.every((entry, i) => entry.seq === first + i)) {
return { entries, anchored: first > 0, base: first - 1 };
}
}
+ if (beforeSeq !== undefined) {
+ const full = await projected(sessionId);
+ return full ? { ...full, entries: full.entries.filter((entry) => entry.seq < beforeSeq) } : null;
+ }
let rows: TapeRecord[];
let anchored = false;
if (limit !== undefined) {
@@ -452,19 +463,22 @@ export function createTranscriptSource(sessions: TranscriptStore): TranscriptSou
return {
async forRender(sessionId, opts?): Promise<TranscriptRead> {
- const read = await projected(sessionId, opts?.limit);
+ const read = await projected(sessionId, opts?.limit, opts?.beforeSeq);
if (read === null) {
const rows = await sessions.getEntries(sessionId, opts);
return { entries: rows, earlier: rows[0]?.seq ?? 0 };
}
const since = opts?.sinceSeq !== undefined ? read.entries.filter((e) => e.seq >= opts.sinceSeq!) : read.entries;
- const entries = opts?.limit !== undefined ? since.slice(-opts.limit) : since;
+ const limit = opts?.beforeSeq !== undefined && !read.anchored ? undefined : opts?.limit;
+ const entries = limit !== undefined ? since.slice(-limit) : since;
const below = read.anchored ? read.base + 1 : 0;
return { entries, earlier: read.entries.length - entries.length + below };
},
async forViewer(sessionId, principalId, opts?): Promise<TranscriptRead> {
const fallback = async (): Promise<TranscriptRead> => ({
- entries: await sessions.visibleEntries(sessionId, principalId),
+ entries: (await sessions.visibleEntries(sessionId, principalId)).filter(
+ (entry) => opts?.beforeSeq === undefined || entry.seq < opts.beforeSeq,
+ ),
earlier: 0,
});
let windows;
@@ -480,11 +494,12 @@ export function createTranscriptSource(sessions: TranscriptStore): TranscriptSou
return fallback();
}
const limit = window.validToSeq === null ? opts?.limit : undefined;
- let read = await projected(sessionId, limit);
+ let read = await projected(sessionId, limit, opts?.beforeSeq);
if (read === null) return fallback();
let filtered = read.entries.filter((e) => entryWithinTenure(e, window));
+ if (opts?.beforeSeq !== undefined && !read.anchored) return { entries: filtered, earlier: 0 };
if (limit !== undefined && filtered.length < limit && (read.entries[0]?.seq ?? 0) > window.validFromSeq) {
- read = await projected(sessionId);
+ read = await projected(sessionId, undefined, opts?.beforeSeq);
if (read === null) return fallback();
filtered = read.entries.filter((e) => entryWithinTenure(e, window));
}
diff --git a/src/sessions/memory-session-store.ts b/src/sessions/memory-session-store.ts
index 83e176d57..8bcfbc45d 100644
--- a/src/sessions/memory-session-store.ts
+++ b/src/sessions/memory-session-store.ts
@@ -290,7 +290,7 @@ export function createMemorySessionStore(opts: StoreOptions = {}): SessionStore
async getEntries(sessionId, opts?: GetEntriesOptions) {
const log = entries.get(sessionId) ?? [];
const since = opts?.sinceSeq ?? 0;
- const filtered = log.filter((e) => e.seq >= since);
+ const filtered = log.filter((e) => e.seq >= since && (opts?.beforeSeq === undefined || e.seq < opts.beforeSeq));
return opts?.limit !== undefined ? filtered.slice(-opts.limit) : filtered;
},
@@ -301,7 +301,10 @@ export function createMemorySessionStore(opts: StoreOptions = {}): SessionStore
if (entry) projected.set(entry.seq, entry);
}
const filtered = [...projected.values()]
- .filter((entry) => entry.seq >= (opts?.sinceSeq ?? 0))
+ .filter(
+ (entry) =>
+ entry.seq >= (opts?.sinceSeq ?? 0) && (opts?.beforeSeq === undefined || entry.seq < opts.beforeSeq),
+ )
.sort((a, b) => a.seq - b.seq);
if (opts?.limit === 0) return [];
return opts?.limit === undefined ? filtered : filtered.slice(-opts.limit);
diff --git a/src/sessions/postgres-session-store.ts b/src/sessions/postgres-session-store.ts
index 3d8669549..453b73285 100644
--- a/src/sessions/postgres-session-store.ts
+++ b/src/sessions/postgres-session-store.ts
@@ -850,11 +850,18 @@ export function createPostgresSessionStore(connectionString: string, opts: Store
},
async getTranscriptEntries(sessionId, opts?: GetEntriesOptions) {
- const rows = await q(
- "SELECT * FROM session_transcript_entries WHERE session_id = $1 AND seq >= $2 ORDER BY seq DESC" +
- (opts?.limit === undefined ? "" : " LIMIT $3"),
- [sessionId, opts?.sinceSeq ?? 0, ...(opts?.limit === undefined ? [] : [opts.limit])],
- );
+ const params: unknown[] = [sessionId, opts?.sinceSeq ?? 0];
+ let sql = "SELECT * FROM session_transcript_entries WHERE session_id = $1 AND seq >= $2";
+ if (opts?.beforeSeq !== undefined) {
+ params.push(opts.beforeSeq);
+ sql += ` AND seq < $${params.length}`;
+ }
+ sql += " ORDER BY seq DESC";
+ if (opts?.limit !== undefined) {
+ params.push(opts.limit);
+ sql += ` LIMIT $${params.length}`;
+ }
+ const rows = await q(sql, params);
return rows.map(rowToEntry).reverse();
},
@@ -905,19 +912,18 @@ export function createPostgresSessionStore(connectionString: string, opts: Store
},
async getEntries(sessionId, opts?: GetEntriesOptions): Promise<SessionEntry[]> {
- const since = opts?.sinceSeq ?? 0;
+ const params: unknown[] = [sessionId, opts?.sinceSeq ?? 0];
+ let sql = "SELECT * FROM session_entries WHERE session_id = $1 AND seq >= $2";
+ if (opts?.beforeSeq !== undefined) {
+ params.push(opts.beforeSeq);
+ sql += ` AND seq < $${params.length}`;
+ }
+ sql += " ORDER BY seq DESC";
if (opts?.limit !== undefined) {
- const rows = await q(
- "SELECT * FROM session_entries WHERE session_id = $1 AND seq >= $2 ORDER BY seq DESC LIMIT $3",
- [sessionId, since, opts.limit],
- );
- return rows.map(rowToEntry).reverse();
+ params.push(opts.limit);
+ sql += ` LIMIT $${params.length}`;
}
- const rows = await q("SELECT * FROM session_entries WHERE session_id = $1 AND seq >= $2 ORDER BY seq ASC", [
- sessionId,
- since,
- ]);
- return rows.map(rowToEntry);
+ return (await q(sql, params)).map(rowToEntry).reverse();
},
async getContextWindow(sessionId) {
diff --git a/src/sessions/session-store.ts b/src/sessions/session-store.ts
index 0a5ee54bb..dcabc2da5 100644
--- a/src/sessions/session-store.ts
+++ b/src/sessions/session-store.ts
@@ -286,6 +286,7 @@ export interface GetTapeOptions {
export interface GetEntriesOptions {
sinceSeq?: number;
+ beforeSeq?: number;
limit?: number;
}
diff --git a/test/postgres-store.test.ts b/test/postgres-store.test.ts
index dfe360de4..281b9a3d9 100644
--- a/test/postgres-store.test.ts
+++ b/test/postgres-store.test.ts
@@ -2256,6 +2256,15 @@ test(
assert.deepEqual(await s.getTranscriptEntries(session.id), before);
assert.deepEqual(await s.getTranscriptEntries(session.id, { limit: 2 }), before.slice(-2));
assert.deepEqual(await s.getTranscriptEntries(session.id, { sinceSeq: 1, limit: 2 }), before.slice(-2));
+ for (const beforeSeq of [0, 1, 3, 4, 99]) {
+ for (const limit of [undefined, 0, 1, 10]) {
+ const expected = before.filter((entry) => entry.seq >= 1 && entry.seq < beforeSeq);
+ let page = expected;
+ if (limit !== undefined) page = limit === 0 ? [] : expected.slice(-limit);
+ assert.deepEqual(await s.getTranscriptEntries(session.id, { sinceSeq: 1, beforeSeq, limit }), page);
+ assert.deepEqual(await s.getEntries(session.id, { sinceSeq: 1, beforeSeq, limit }), page);
+ }
+ }
assert.equal(await s.tapeCoverage(session.id), -1);
assert.equal(await s.clearSecurityTaint(session.id), true);
const after = await s.getEntries(session.id);
diff --git a/test/session-view-bounds.test.ts b/test/session-view-bounds.test.ts
index 0347af096..dc0937e6c 100644
--- a/test/session-view-bounds.test.ts
+++ b/test/session-view-bounds.test.ts
@@ -185,3 +185,90 @@ test("canonical transcripts retain foreign harness tool detail and exact bounded
await built.runtime.stop();
}
});
+
+test("earlier pages bound canonical reads, widen for dense turns, and match full-read windows", async () => {
+ const built = freshApp();
+ try {
+ const { session } = await coarseForeignSession(built.sessions, 100);
+ const canonical = built.sessions.getTranscriptEntries.bind(built.sessions);
+ const calls: Array<{ limit?: number; beforeSeq?: number } | undefined> = [];
+ built.sessions.getTranscriptEntries = async (id, opts) => {
+ calls.push(opts);
+ return canonical(id, opts);
+ };
+ for (const beforeSeq of [1, 50, 251, 499, 900]) {
+ const full = (await built.app.getSessionForViewer(session.id, "U1"))!;
+ calls.length = 0;
+ const window = { beforeSeq, tailTurns: 2 };
+ const expected = windowedTranscript(full.entries as SessionEntry[], window);
+ for (const page of [
+ await built.app.getSessionForViewer(session.id, "U1", window),
+ await built.app.getSession(session.id, window),
+ ]) {
+ assert.deepEqual(page!.entries, expected.entries);
+ assert.equal(page!.earlierEntries ?? 0, expected.earlier);
+ }
+ assert.ok(calls.every((opts) => opts?.beforeSeq === beforeSeq && opts.limit === 80));
+ }
+ const { lease } = await built.sessions.acquireLease(session.id);
+ for (let i = 0; i < 180; i++)
+ await built.sessions.append(lease!, {
+ type: "text",
+ payload: { text: `detail ${i}` },
+ scopeLabel: session.scopeId,
+ });
+ await built.sessions.releaseLease(lease!);
+ calls.length = 0;
+ const page = await built.app.getSessionForViewer(session.id, "U1", { beforeSeq: 680, tailTurns: 1 });
+ assert.equal(page!.entries[0]!.seq, 495);
+ assert.deepEqual(
+ calls.map((opts) => opts?.limit),
+ [40, 80, 160, 320],
+ );
+ } finally {
+ await built.runtime.stop();
+ }
+});
+
+test("earlier pages retain tape fallback and viewer tenure boundaries", async () => {
+ const built = freshApp();
+ try {
+ const { session } = await coarseForeignSession(built.sessions, 30);
+ await built.sessions.addParticipant(session.id, "late");
+ const { lease } = await built.sessions.acquireLease(session.id);
+ for (let i = 0; i < 10; i++) {
+ await built.sessions.append(lease!, {
+ type: "user",
+ payload: { text: `late question ${i}` },
+ scopeLabel: session.scopeId,
+ });
+ await built.sessions.append(lease!, {
+ type: "assistant",
+ payload: { text: `late reply ${i}` },
+ scopeLabel: session.scopeId,
+ });
+ }
+ await built.sessions.releaseLease(lease!);
+ for (const viewer of ["late", "U1", "stranger"]) {
+ const full = await built.app.getSessionForViewer(session.id, viewer);
+ for (const beforeSeq of [100, 155, 170]) {
+ const page = await built.app.getSessionForViewer(session.id, viewer, { beforeSeq, tailTurns: 2 });
+ if (!full) {
+ assert.equal(page, null);
+ continue;
+ }
+ const expected = windowedTranscript(full.entries as SessionEntry[], { beforeSeq, tailTurns: 2 });
+ assert.deepEqual(page!.entries, expected.entries);
+ assert.equal(page!.earlierEntries ?? 0, expected.earlier);
+ }
+ }
+ withoutCanonicalTranscript(built.sessions);
+ const full = (await built.app.getSession(session.id))!;
+ const expected = windowedTranscript(full.entries as SessionEntry[], { beforeSeq: 101, tailTurns: 2 });
+ const page = (await built.app.getSessionForViewer(session.id, "U1", { beforeSeq: 101, tailTurns: 2 }))!;
+ assert.deepEqual(page.entries, expected.entries);
+ assert.equal(page.earlierEntries ?? 0, expected.earlier);
+ } finally {
+ await built.runtime.stop();
+ }
+});
diff --git a/test/tape-projection.test.ts b/test/tape-projection.test.ts
index 62f92f68e..47b1a8635 100644
--- a/test/tape-projection.test.ts
+++ b/test/tape-projection.test.ts
@@ -1044,6 +1044,38 @@ test("forViewer with a limit reads a bounded tape suffix for an active participa
);
});
+test("an earlier-page tape fallback keeps its full prefix without repeated dense-turn reads", async () => {
+ const sim = await simSession();
+ await sim.store.addParticipant(sim.session.id, "viewer", undefined, { includeHistory: true });
+ await simTurn(sim, {
+ input: "a dense turn",
+ reply: "done",
+ steps: Array.from({ length: 90 }, (_, i) => ({
+ calls: [
+ {
+ id: `c${i}`,
+ name: "execute",
+ args: { command: "work" },
+ result: "done",
+ },
+ ],
+ })),
+ });
+ const expected = (await sim.store.getEntries(sim.session.id)).filter((entry) => entry.seq < 181);
+ const { store, calls } = tapeSpy(sim);
+ const source = createTranscriptSource(store);
+ for (const read of [
+ () => source.forRender(sim.session.id, { beforeSeq: 181, limit: 40 }),
+ () => source.forViewer(sim.session.id, "viewer", { beforeSeq: 181, limit: 40 }),
+ ]) {
+ calls.length = 0;
+ const page = await read();
+ assert.deepEqual(page.entries, expected);
+ assert.equal(page.earlier, 0);
+ assert.deepEqual(calls, [undefined]);
+ }
+});
+
test("forViewer refetches in full when a late joiner's window under-fills the limit", async () => {
const sim = await simSession();
await simTurn(sim, { input: "before the join", reply: "old reply" });