clank/clank-together
1
0
Fork 0
Code Issues Wiki Activity

Regions, competing candidates, five "same" merge, checks compile locally

Browse source 
- Agents list regions (source files or classes: open, done, in flight,
  who claimed them), claim one as a whole and submit it in one batch.
- Several agents may claim a region; each may submit any function of it.
  Candidates are verified and reviewed on their own; the first accepted
  one merges and the others are superseded, the rest of their batches
  goes on. A done task stays done (trigger).
- Peer review: five "same" accept (no human step), three "different"
  send back.
- The server no longer compiles checks (remoteChecks, off by default);
  approved accounts download the compiler package for local checks.
- Tables for game credits and rounds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Saty 2026-10-20 02:32:20 +02:00
commit 10f840b18f
8 changed files with 488 additions and 75 deletions
Download patch file Download diff file Expand all files Collapse all files

132
test/server.test.js
View file

@ -20,7 +20,7 @@ const quiet = { info() {}, error() {}, warn() {} };
before(async () => {
dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'td-test-'));
fs.writeFileSync(path.join(dataDir, 'server.json'), JSON.stringify({ listen: { host: '127.0.0.1', port: 0 }, verifyConcurrency: 1 }));
fs.writeFileSync(path.join(dataDir, 'server.json'), JSON.stringify({ listen: { host: '127.0.0.1', port: 0 }, verifyConcurrency: 1, remoteChecks: true }));
const repoDir = path.join(dataDir, 'repo');
fs.cpSync(path.join(ROOT, 'template'), repoDir, { recursive: true });
const git = (...a) => execFileSync('git', a, { cwd: repoDir, stdio: 'pipe' });
@ -297,12 +297,14 @@ test('changing the password logs out browser sessions', async () => {
await login('erin', 'a brand new password');
});
test('peer review: three other agents must agree, by reading only', async () => {
test('peer review: five "same" accept, three "different" send back, by reading only', async () => {
const author = await activeUser('pauthor');
const r1 = await activeUser('peer1');
const r2 = await activeUser('peer2');
const r3 = await activeUser('peer3');
const r4 = await activeUser('peer4');
const r5 = await activeUser('peer5');
const r6 = await activeUser('peer6');
ctx.merger.pump = async () => {};
const authorId = ctx.accounts.byName('pauthor').id;
@ -319,23 +321,25 @@ test('peer review: three other agents must agree, by reading only', async () =>
assert.ok(!(await call('GET', '/api/peer-reviews', null, author)).body.some((x) => x.attempt_id === attempt), 'authors do not see their own attempts');
const claim = await call('POST', '/api/peer-reviews/claim', { attemptId: attempt }, r1);
assert.equal(claim.status, 200);
assert.equal(claim.body.required, 3);
assert.equal(claim.body.required, 5);
assert.equal(claim.body.rejectAt, 3);
assert.ok(claim.body.instructions.some((i) => /Do not compile/.test(i)));
assert.equal(JSON.stringify(claim.body).includes('diffRegions'), false, 'no machine verdict in the review context');
assert.equal(claim.body.original.read[0], `td_disassemble ${task.symbol_id}`);
await call('POST', '/api/peer-reviews/claim', { attemptId: attempt }, r2);
await call('POST', '/api/peer-reviews/claim', { attemptId: attempt }, r3);
assert.equal((await call('POST', '/api/peer-reviews/claim', { attemptId: attempt }, r4)).status, 409, 'no more reviewers than needed');
for (const r of [r2, r3, r4, r5]) await call('POST', '/api/peer-reviews/claim', { attemptId: attempt }, r);
assert.equal((await call('POST', '/api/peer-reviews/claim', { attemptId: attempt }, r6)).status, 409, 'no more reviewers than needed');
assert.equal((await call('POST', `/api/peer-reviews/${attempt}/verdict`, { verdict: 'same', reason: 'short' }, r1)).status, 400);
assert.equal((await call('POST', `/api/peer-reviews/${attempt}/verdict`, { verdict: 'same', reason: 'all branches and calls agree' }, author)).status, 403);
assert.equal((await call('POST', `/api/peer-reviews/${attempt}/verdict`, { verdict: 'same', reason: 'all branches and calls agree' }, r1)).body.state, 'peer_review');
assert.equal((await call('POST', `/api/peer-reviews/${attempt}/verdict`, { verdict: 'same', reason: 'same loop bounds and the same return' }, r1)).status, 409, 'one verdict per account');
assert.equal((await call('POST', `/api/peer-reviews/${attempt}/verdict`, { verdict: 'same', reason: 'checked every condition and field access' }, r2)).body.state, 'peer_review');
const done = await call('POST', `/api/peer-reviews/${attempt}/verdict`, { verdict: 'same', reason: 'identical behavior, only register use differs' }, r3);
assert.equal(done.body.state, 'in_review');
assert.equal(ctx.tasks.get(task.id).state, 'in_review');
assert.equal((await call('POST', `/api/peer-reviews/${attempt}/verdict`, { verdict: 'same', reason: 'identical behavior, only register use differs' }, r3)).body.state, 'peer_review', 'three are not enough to accept');
assert.equal((await call('POST', `/api/peer-reviews/${attempt}/verdict`, { verdict: 'same', reason: 'same calls in the same order, same result' }, r4)).body.state, 'peer_review');
const done = await call('POST', `/api/peer-reviews/${attempt}/verdict`, { verdict: 'same', reason: 'same fields read and written, same return' }, r5);
assert.equal(done.body.state, 'approved', 'five accept it, with no human step');
assert.equal(ctx.tasks.get(task.id).state, 'approved');
assert.ok(ctx.peers.confirmed(attempt));
// One "different" is not enough: it stays in review until three agree, here after a mixed round.
@ -436,16 +440,16 @@ test('five agreeing peers accept a function without human review, also over an o
const clean = make(0x401900);
for (let i = 0; i < 3; i++) await review(clean.attempt, peers[i], 'same');
assert.equal(ctx.store.get('SELECT state FROM attempts WHERE id = ?', clean.attempt).state, 'in_review', 'three send it to a human');
assert.equal((await review(clean.attempt, peers[3], 'same')).state, 'in_review', 'it stays open for more reviewers');
assert.equal(ctx.store.get('SELECT state FROM attempts WHERE id = ?', clean.attempt).state, 'peer_review', 'three are not enough');
assert.equal((await review(clean.attempt, peers[3], 'same')).state, 'peer_review', 'it stays open for more reviewers');
assert.equal((await review(clean.attempt, peers[4], 'same')).state, 'approved', 'five accept it');
assert.equal(ctx.store.get('SELECT state FROM tasks WHERE id = ?', clean.task).state, 'approved');
const contested = make(0x401940);
await review(contested.attempt, peers[0], 'different');
for (let i = 1; i <= 3; i++) await review(contested.attempt, peers[i], 'same');
assert.equal(ctx.store.get('SELECT state FROM attempts WHERE id = ?', contested.attempt).state, 'in_review');
assert.equal((await review(contested.attempt, peers[4], 'same')).state, 'in_review');
assert.equal(ctx.store.get('SELECT state FROM attempts WHERE id = ?', contested.attempt).state, 'peer_review');
assert.equal((await review(contested.attempt, peers[4], 'same')).state, 'peer_review');
assert.equal((await review(contested.attempt, peers[5], 'same')).state, 'approved', 'five "same" accept it over one objection (flagged for later at merge)');
for (const x of [clean, contested]) {
@ -623,7 +627,7 @@ test('the review list skips fully leased functions before applying its limit', a
const author = ctx.accounts.byName('rlauthor');
const viewer = ctx.accounts.byName('rlviewer');
const others = [];
for (let i = 1; i <= 3; i++) {
for (let i = 1; i <= 5; i++) {
await activeUser(`rlpeer${i}`);
others.push(ctx.accounts.byName(`rlpeer${i}`));
}
@ -639,7 +643,7 @@ test('the review list skips fully leased functions before applying its limit', a
const free = make(0x410040);
for (const o of others) ctx.store.run('INSERT INTO peer_leases (attempt_id, reviewer_id, expires_at) VALUES (?, ?, ?)', full.attempt, o.id, now() + 3600_000);
const ids = ctx.peers.available(viewer, 200).map((r) => r.attempt_id);
assert.ok(!ids.includes(full.attempt), 'three reviewers on it already');
assert.ok(!ids.includes(full.attempt), 'five reviewers on it already');
assert.ok(ids.includes(free.attempt));
for (const x of [full, free]) {
ctx.store.run('DELETE FROM peer_leases WHERE attempt_id = ?', x.attempt);
@ -872,7 +876,8 @@ test('approving a batch leaves its functions in peer review alone unless asked',
test('split: the approved part of a batch merges while the rest waits for review', async () => {
const author = await activeUser('sauthor');
const peers = [await activeUser('speer1'), await activeUser('speer2'), await activeUser('speer3')];
const peers = [];
for (let i = 1; i <= 5; i++) peers.push(await activeUser(`speer${i}`));
await ctx.accounts.createUser('sreviewer', 'reviewer', PASSWORD);
const reviewer = await login('sreviewer');
delete ctx.merger.pump;
@ -917,13 +922,14 @@ test('split: the approved part of a batch merges while the rest waits for review
assert.equal(rest.base_commit, head1);
assert.equal(JSON.parse(rest.files_json)['src/split.cpp'], source);
// D passes review later and merges on top.
// D passes review later (five "same", no human step) and merges on top.
const att = (await batchState(s.body.batchId)).functions.find((f) => f.symbol === d).attemptId;
for (const t of peers) {
await call('POST', '/api/peer-reviews/claim', { attemptId: att }, t);
await call('POST', `/api/peer-reviews/${att}/verdict`, { verdict: 'same', reason: 'same branches and return values' }, t);
}
assert.equal((await request('POST', `/api/batches/${s.body.batchId}/review`, { action: 'approve' }, { cookie: reviewer })).status, 200);
assert.equal(ctx.store.get('SELECT state FROM attempts WHERE id = ?', att).state, 'approved');
void reviewer;
await ctx.merger.pump();
assert.equal(ctx.store.get('SELECT state FROM batches WHERE id = ?', s.body.batchId).state, 'merged');
assert.equal(ctx.repo.show(ctx.repo.head(), 'src/split.cpp'), source);
@ -933,7 +939,8 @@ test('split: the approved part of a batch merges while the rest waits for review
test('batches: one compile, auto-approval, peer review, one function sent back, carry-over', async () => {
const author = await activeUser('bauthor');
const peers = [await activeUser('bpeer1'), await activeUser('bpeer2'), await activeUser('bpeer3')];
const peers = [];
for (let i = 1; i <= 5; i++) peers.push(await activeUser(`bpeer${i}`));
await ctx.accounts.createUser('breviewer', 'reviewer', PASSWORD);
const reviewer = await login('breviewer');
delete ctx.merger.pump; // an earlier test stubbed it on the instance; use the real one here
@ -982,7 +989,7 @@ test('batches: one compile, auto-approval, peer review, one function sent back,
// Round 1: a peer claim covers the batch's waiting functions; all three find a difference.
const pc = await call('POST', '/api/peer-reviews/claim', { attemptId: r1[b].attemptId }, peers[0]);
assert.deepEqual(pc.body.functions.map((f) => f.symbol), [b]);
for (const t of peers) {
for (const t of peers.slice(0, 3)) {
await call('POST', '/api/peer-reviews/claim', { attemptId: r1[b].attemptId }, t);
await call('POST', `/api/peer-reviews/${r1[b].attemptId}/verdict`, { verdict: 'different', reason: 'the original checks the flag first, this does not' }, t);
}
@ -995,9 +1002,9 @@ test('batches: one compile, auto-approval, peer review, one function sent back,
assert.equal(ctx.store.get('SELECT state FROM tasks WHERE symbol_id = ?', a).state, 'done');
assert.equal((await batchState(s1.body.batchId)).state, 'returned');
// Round 2: the author fixes B (new fingerprint) and resubmits it; three peers confirm.
// Round 2: the author fixes B (new fingerprint) and resubmits it; five peers confirm.
bHash = 'hash-b-2';
const objector = await activeUser('bpeer4');
const objector = await activeUser('bpeer6');
const taskOfB = claim.body.tasks.find((t) => t.symbol === b).task;
assert.equal((await call('POST', '/api/tasks/claim', { taskId: taskOfB }, author)).status, 200);
const s2 = await call('POST', '/api/batches', { taskIds: [taskOfB], baseCommit: ctx.repo.head(), files: { 'src/batch.cpp': source } }, author);
@ -1009,11 +1016,8 @@ test('batches: one compile, auto-approval, peer review, one function sent back,
await call('POST', '/api/peer-reviews/claim', { attemptId: r2[b].attemptId }, t);
await call('POST', `/api/peer-reviews/${r2[b].attemptId}/verdict`, { verdict: 'same', reason: 'now checks the flag first like the original' }, t);
}
assert.equal((await batchState(s2.body.batchId)).functions.find((f) => f.symbol === b).state, 'in_review');
// One human click for the batch; one merge commit.
const rev = await request('POST', `/api/batches/${s2.body.batchId}/review`, { action: 'approve' }, { cookie: reviewer });
assert.equal(rev.status, 200, JSON.stringify(rev.body));
assert.equal((await batchState(s2.body.batchId)).functions.find((f) => f.symbol === b).state, 'approved', 'five "same" accept it over one objection');
void reviewer;
// Nothing on main changed since verification: the merge reuses that compile.
let compiles = 0;
const counted = ctx.verifier.check;
@ -1041,3 +1045,77 @@ test('batches: one compile, auto-approval, peer review, one function sent back,
ctx.verifier.check = realCheck;
});
test('regions: two agents claim one file, the first accepted candidate merges, the other is superseded', async () => {
const first = await activeUser('rgfirst');
const second = await activeUser('rgsecond');
delete ctx.merger.pump;
const v = ctx.store.currentVersion();
const e = ctx.store.ensureSymbol({ kind: 'function', versionId: v.id, addr: 0x402700, size: 8, unit: 'src/region.cpp' }).symbol.id;
const f = ctx.store.ensureSymbol({ kind: 'function', versionId: v.id, addr: 0x402740, size: 8, unit: 'src/region.cpp' }).symbol.id;
ctx.tasks.generate();
// Stubbed compiler: whoever's file has "return 7" in fe matches; fe of the other candidate does not.
const realCheck = ctx.verifier.check;
ctx.verifier.check = async (files) => {
const text = files['src/region.cpp'] ?? '';
const functions = [];
if (text.includes('int fe()')) functions.push({ id: e, status: text.includes('return 7') ? STATUS.EXACT : STATUS.MISMATCH, score: text.includes('return 7') ? 1 : 0.8, file: 'src/region.cpp', codeHash: text.includes('return 7') ? 'e-good' : 'e-other', relocations: [], size: { ours: 8, original: 8 } });
if (text.includes('int ff()')) functions.push({ id: f, status: STATUS.MISMATCH, score: 0.9, file: 'src/region.cpp', codeHash: 'f-1', relocations: [], size: { ours: 8, original: 8 } });
return { check: { annotationErrors: [], units: [{ file: 'src/region.cpp', compiled: true, lintErrors: [], unannotated: [], bindings: {}, inferred: [], includes: [], errors: [], functions }] }, rec: { conflicts: [], unknown: [], learned: [], learnedAddresses: [] }, changedHeaders: [], units: ['src/region.cpp'] };
};
const list = (await call('GET', '/api/regions?prefix=src/region', null, first)).body;
const region = list.regions.find((r) => r.key === 'src/region.cpp');
assert.deepEqual([region.open, region.free], [2, true], 'unclaimed and open');
const c1 = await call('POST', '/api/regions/claim', { kind: 'unit', key: 'src/region.cpp' }, first);
assert.equal(c1.status, 200, JSON.stringify(c1.body));
assert.equal(c1.body.leased.length, 2, 'the whole region at once');
const c2 = await call('POST', '/api/regions/claim', { kind: 'unit', key: 'src/region.cpp' }, second);
assert.equal(c2.status, 200);
assert.deepEqual(c2.body.alsoClaimedBy, ['rgfirst']);
assert.ok(c2.body.functions.every((x) => x.shared), 'held by the first agent, shared with the second');
assert.equal((await call('GET', '/api/regions?prefix=src/region', null, first)).body.regions[0].free, false);
const taskOf = (sym) => c1.body.functions.find((x) => x.symbol === sym).taskId;
const head = ctx.repo.head();
const batchState = async (id, token) => (await call('GET', `/api/batches/${id}`, null, token)).body;
const settle = (id, token) => waitFor(async () => { const st = await batchState(id, token); return !['queued', 'verifying'].includes(st.state) && st; });
// The second agent's candidate of fe matches; the first agent's does not.
const s2 = await call('POST', '/api/batches', { taskIds: [taskOf(e)], baseCommit: head, files: { 'src/region.cpp': `// FUNCTION: ${e}\nint fe() { return 7; }\n` } }, second);
assert.equal(s2.status, 200, JSON.stringify(s2.body));
assert.equal(s2.body.attempts[0].competing, true);
assert.equal(ctx.tasks.get(taskOf(e)).state, 'leased', 'a competing candidate leaves the holder\'s lease alone');
const s1 = await call('POST', '/api/batches', { taskIds: [taskOf(e), taskOf(f)], baseCommit: head, files: { 'src/region.cpp': `// FUNCTION: ${e}\nint fe() { return 6; }\n\n// FUNCTION: ${f}\nint ff() { return 8; }\n` } }, first);
assert.equal(s1.status, 200, JSON.stringify(s1.body));
await settle(s2.body.batchId, second);
await settle(s1.body.batchId, first);
await ctx.merger.pump();
assert.equal((await batchState(s2.body.batchId, second)).state, 'merged');
assert.equal(ctx.tasks.get(taskOf(e)).state, 'done');
const loser = (await batchState(s1.body.batchId, first)).functions.find((x) => x.symbol === e);
assert.equal(loser.state, 'superseded', 'the other candidate of the merged function is not needed any more');
assert.equal((await batchState(s1.body.batchId, first)).functions.find((x) => x.symbol === f).state, 'peer_review', 'the rest of its batch goes on');
// A done function stays done whatever a late candidate does.
ctx.store.run(`UPDATE tasks SET state = 'needs_cleanup' WHERE id = ?`, taskOf(e));
assert.equal(ctx.tasks.get(taskOf(e)).state, 'done');
assert.equal((await call('POST', '/api/regions/release', { kind: 'unit', key: 'src/region.cpp' }, second)).status, 200);
ctx.store.run(`UPDATE attempts SET state = 'rejected' WHERE batch_id = ?`, s1.body.batchId);
ctx.store.run(`UPDATE tasks SET state = 'done' WHERE id = ?`, taskOf(f));
ctx.store.run('DELETE FROM region_claims');
ctx.verifier.check = realCheck;
});
test('the server does not compile checks unless remoteChecks is on', async () => {
const user = await activeUser('rcuser');
ctx.config.remoteChecks = false;
const r = await call('POST', '/api/check', { baseCommit: ctx.repo.head(), files: {} }, user);
assert.equal(r.status, 410);
assert.match(r.body.error, /td toolchain install/);
ctx.config.remoteChecks = true;
});