Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript

fix: pre-landing review fixes

garrytane030681cf55c
diff --git a/.github/workflows/tla-spec.yml b/.github/workflows/tla-spec.yml
index 087197ff5e..0286c21939 100644
--- a/.github/workflows/tla-spec.yml
+++ b/.github/workflows/tla-spec.yml
@@ -44,6 +44,10 @@ on:
- 'src/core/persistence/coordinator.ts'
- 'src/core/persistence/group-publish.ts'
- 'src/core/persistence/page-prepare.ts'
+ - 'src/core/persistence/topology-locks.ts'
+ - 'src/core/persistence/authority.ts'
+ - 'src/core/persistence/import-deferral.ts'
+ - 'src/core/persistence/local-edit-adoption.ts'
- 'test/persistence-worktree-refresh.test.ts'
- 'test/pending-import-async-git-7436.test.ts'
push:
@@ -84,6 +88,10 @@ on:
- 'src/core/persistence/coordinator.ts'
- 'src/core/persistence/group-publish.ts'
- 'src/core/persistence/page-prepare.ts'
+ - 'src/core/persistence/topology-locks.ts'
+ - 'src/core/persistence/authority.ts'
+ - 'src/core/persistence/import-deferral.ts'
+ - 'src/core/persistence/local-edit-adoption.ts'
- 'test/persistence-worktree-refresh.test.ts'
- 'test/pending-import-async-git-7436.test.ts'
schedule:
@@ -151,6 +159,7 @@ jobs:
env:
DATABASE_URL: postgres://gbrain_test:[email protected]:5432/gbrain_test
GBRAIN_TEST_ALLOW_DATABASE_URL: '1'
+ TLC_TIMEOUT_S: '900'
run: bun scripts/spec/mutants.ts ${{ matrix.spec }} --require-postgres
- name: Keep the logs and counterexample traces
if: always()
diff --git a/spec/tla/README.md b/spec/tla/README.md
index 8c521222e7..8f8300beab 100644
--- a/spec/tla/README.md
+++ b/spec/tla/README.md
@@ -21,7 +21,7 @@ Needs Java 11 or later (CI uses temurin 21), GNU `timeout` (`brew install coreut
`scripts/spec/tla-tools.env`; set `TLA2TOOLS` to use a jar you already have (it is checked too). The code mutants
that need Postgres run when `DATABASE_URL` points at a test database (with `GBRAIN_TEST_ALLOW_DATABASE_URL=1`);
otherwise they print `skip`, and CI passes `--require-postgres`. Logs and counterexample traces land in
-`.context/tlc/` (`TLC_OUT`), and CI uploads them as the `tla-spec-logs` artifact.
+`.context/tlc/` (`TLC_OUT`), and CI uploads them as the `tla-spec-logs-<spec>` artifact (`tla-spec-logs-refresh-barrier`, for example).
`.github/workflows/tla-spec.yml` runs all of it, one job per spec, nightly, on dispatch, and on pull requests and master pushes that touch a
spec, its runner, the code a spec models, or a test a mutant names.
diff --git a/test/import-write-barrier.test.ts b/test/import-write-barrier.test.ts
index 0f87f7560b..87347dd58c 100644
--- a/test/import-write-barrier.test.ts
+++ b/test/import-write-barrier.test.ts
@@ -332,26 +332,31 @@ test.skipIf(!backends.includes('postgres'))('an import expiry that overlaps a fe
await new Promise(resolve => setTimeout(resolve, 20));
const owner = await ownerHost(f);
let holding!: () => void; const held1 = new Promise<void>(resolve => { holding = resolve; });
+ let fenceIs!: (rows: Array<{ pid: number }>) => void; const fencePid = new Promise<Array<{ pid: number }>>(resolve => { fenceIs = resolve; });
let waiting!: () => void; const expiryWaits = new Promise<void>(resolve => { waiting = resolve; });
// fenceDraining's order (lockTopologyRows): the brain row FOR UPDATE, then the worktree, then the sources.
const fence = f.engine.transaction(async tx => {
await tx.executeRaw("SELECT set_config('lock_timeout','10s',true)");
await tx.executeRaw('SELECT singleton FROM persistence_brain WHERE singleton=1 FOR UPDATE');
+ fenceIs(await tx.executeRaw<{ pid: number }>('SELECT pg_backend_pid() AS pid'));
holding();
await expiryWaits;
await tx.executeRaw('SELECT 1 FROM sources WHERE id=$1 FOR UPDATE', [f.alpha]);
});
await held1;
const expiry = expireDeferredWrites(f.engine, owner);
- for (let i = 0; i < 400; i++) {
- const [w] = await f.engine.executeRaw<{ n: number }>("SELECT count(*)::int AS n FROM pg_stat_activity WHERE datname=current_database() AND wait_event_type='Lock'");
- if (Number(w!.n) > 0) break;
- await new Promise(resolve => setTimeout(resolve, 25));
+ const [{ pid }] = await fencePid;
+ let blocked = false;
+ for (let i = 0; i < 400 && !blocked; i++) {
+ const [w] = await f.engine.executeRaw<{ n: number }>('SELECT count(*)::int AS n FROM pg_stat_activity WHERE $1::int = ANY(pg_blocking_pids(pid))', [pid]);
+ blocked = Number(w!.n) > 0;
+ if (!blocked) await new Promise(resolve => setTimeout(resolve, 25));
}
waiting();
const [fenced, expired] = await Promise.allSettled([fence, expiry]);
expect(fenced.status === 'rejected' ? String(fenced.reason) : 'fence committed').toBe('fence committed');
expect(expired.status === 'fulfilled' ? expired.value.map(row => row.id) : String(expired.reason)).toEqual([held.id]);
+ expect(blocked).toBe(true);
} finally {
await f.engine.executeRaw("DELETE FROM config WHERE key='persistence.refresh_barrier_max_wait_ms'");
}
diff --git a/test/refresh-write-barrier.test.ts b/test/refresh-write-barrier.test.ts
index 557b2b0014..f99d5fa400 100644
--- a/test/refresh-write-barrier.test.ts
+++ b/test/refresh-write-barrier.test.ts
@@ -99,9 +99,10 @@ async function settle(f: RefreshFixture, row: WriteRequest): Promise<WriteReques
/**
* Postgres only: on a separate connection, moves refresh `refreshId` to aborted and keeps that transaction open while `start`
- * runs, until `start` waits on that connection's lock (or settles), then commits and returns what `start` returns.
+ * runs, until `start` waits on that connection's lock (or settles), then commits and returns what `start` returns and
+ * whether it waited on that lock (a race test that never waited proves nothing).
*/
-async function endRefreshDuring<T>(f: RefreshFixture, refreshId: string, start: () => Promise<T>): Promise<T> {
+async function endRefreshDuring<T>(f: RefreshFixture, refreshId: string, start: () => Promise<T>): Promise<{ value: T; blocked: boolean }> {
const sql = postgres(postgresUrl!, { max: 1, prepare: false });
try {
const conn = await sql.reserve();
@@ -109,16 +110,16 @@ async function endRefreshDuring<T>(f: RefreshFixture, refreshId: string, start:
await conn.unsafe('BEGIN');
const [{ pid }] = await conn.unsafe<Array<{ pid: number }>>('SELECT pg_backend_pid() AS pid');
await conn.unsafe("UPDATE persistence_worktree_refreshes SET state='aborted',completed_at=now(),updated_at=now() WHERE id=$1::uuid", [refreshId]);
- let settled = false;
+ let settled = false; let blocked = false;
const running = start().finally(() => { settled = true; });
running.catch(() => undefined);
for (let i = 0; i < 800 && !settled; i++) {
const [waiting] = await f.engine.executeRaw<{ n: number }>('SELECT count(*)::int AS n FROM pg_stat_activity WHERE $1::int = ANY(pg_blocking_pids(pid))', [pid]);
- if (Number(waiting!.n) > 0) break;
+ if (Number(waiting!.n) > 0) { blocked = true; break; }
await new Promise(resolve => setTimeout(resolve, 25));
}
await conn.unsafe('COMMIT');
- return await running;
+ return { value: await running, blocked };
} finally { conn.release(); }
} finally { await sql.end(); }
}
@@ -241,9 +242,10 @@ test('an expiry racing the end of its refresh leaves the write deferred, and it
try {
await new Promise(resolve => setTimeout(resolve, 20));
const [{ owner }] = await f.engine.executeRaw<{ owner: string }>('SELECT owner_host_id::text AS owner FROM persistence_worktrees WHERE id=$1::uuid', [f.worktreeId]);
- const expired = await endRefreshDuring(f, deferred.deferred_refresh_id!, () => expireDeferredWrites(f.engine, owner));
+ const { value: expired, blocked } = await endRefreshDuring(f, deferred.deferred_refresh_id!, () => expireDeferredWrites(f.engine, owner));
expect(expired.map(row => row.id)).toEqual([]);
expect((await getWriteRequestById(f.engine, deferred.id))!.state).toBe('deferred');
+ expect(blocked).toBe(true);
} finally {
await f.engine.executeRaw("DELETE FROM config WHERE key='persistence.refresh_barrier_max_wait_ms'");
}
@@ -256,10 +258,11 @@ test('a write admitted while its refresh ends is never deferred to the released
let row!: WriteRequest;
await duringRefresh(f, async () => {
const active = (await f.refreshRows()).find(r => r.state === 'draining')!;
- const out = await endRefreshDuring(f, active.id, () => call(f, 'put_page', { slug: 'notes/admission-race', content: page('Admission race', 'body') }));
+ const { value: out, blocked } = await endRefreshDuring(f, active.id, () => call(f, 'put_page', { slug: 'notes/admission-race', content: page('Admission race', 'body') }));
row = await requestRow(f, out.body.request_id);
expect(row.deferred_refresh_id).toBeNull();
expect(row.state).not.toBe('deferred');
+ expect(blocked).toBe(true);
}).catch(error => { if (!(error instanceof OperationError)) throw error; });
expect((await settle(f, row)).state).toBe('committed');
}), 180_000);