Skip to content

Autonomous development for real products. Governed agents build from specs you approve, follow the rules you set, and nothing merges until another agent proves it. Your decisions, judgement and taste are the bar that work must clear. Declare your vision and let agents build it.

fix(verdict): bind carry replay and merge boundaries [V1,V4,H16]

Corey Olsonc49d7708d624
diff --git a/src/board.js b/src/board.js
index f3f4613c..aed49ff4 100644
--- a/src/board.js
+++ b/src/board.js
@@ -115,7 +115,10 @@ import {
unreadShoutBindings,
} from './shout-audience.js';
import { recordVerdict } from './verdict-assurance.js';
-import { mergeOnlyBasis, mergeOnlyProblem } from './merge-only-verdict.js';
+import {
+ mergeOnlyBasis,
+ mergeOnlyProblem,
+} from './merge-only-verdict.js';
import { MERGE_ONLY_VERDICT_ENGINE } from './merge-only-verdict-engine.js';
import {
atomic,
diff --git a/src/merge-only-source.js b/src/merge-only-source.js
index 35bb9f35..ab9a0811 100644
--- a/src/merge-only-source.js
+++ b/src/merge-only-source.js
@@ -3,10 +3,12 @@ import { spawnSync } from 'node:child_process';
import { cleanGitEnvironment } from './git.js';
/** Read immutable objects with fixed merge rules, bounded time/output and no external diff drivers. */
-function readGit(root, args, statuses = [0]) {
+function readGit(root, args, statuses, deadline) {
+ const remaining = Math.min(5000, deadline - Date.now());
+ if (remaining <= 0) throw new Error('merge proof budget exhausted');
const result = spawnSync('git', ['--no-replace-objects', '-c', 'merge.conflictStyle=merge',
'-c', 'core.attributesFile=/dev/null', ...args], {
- cwd: root, env: cleanGitEnvironment(), encoding: 'utf8', timeout: 5000, maxBuffer: 2 * 1024 * 1024,
+ cwd: root, env: cleanGitEnvironment(), encoding: 'utf8', timeout: remaining, maxBuffer: 2 * 1024 * 1024,
});
if (result.error || !statuses.includes(result.status)) throw new Error('merge source unavailable');
return result.stdout;
@@ -41,32 +43,38 @@ function conflictEditsOnly(source, patch, accepted, trunk) {
/** Return a replayable source receipt, or null so an uncertain/changed build gets normal review. */
export function captureMergeOnly(root, basis, { commit, tree, trunk }) {
if (!basis) return null;
+ const deadline = Date.now() + 10000;
+ /** Share one total deadline across this bounded set of immutable object reads. */
+ const read = (args, statuses = [0]) => readGit(root, args, statuses, deadline);
try {
// An external merge driver is mutable executable policy, not a proof from immutable trees.
- if (readGit(root, ['config', '--get-regexp', '^merge\\..*\\.driver$'], [0, 1]).trim()) return null;
- const parents = readGit(root, ['show', '-s', '--format=%P', commit]).trim().split(' ');
+ if (read(['config', '--get-regexp', '^merge\\..*\\.driver$'], [0, 1]).trim()) return null;
+ const parents = read(['show', '-s', '--format=%P', commit]).trim().split(' ');
if (parents.length !== 2 || parents[0] !== basis.acceptedHead || parents[1] !== trunk) return null;
- readGit(root, ['merge-base', '--is-ancestor', basis.conflict.trunk, trunk]);
- const acceptedTree = readGit(root, ['rev-parse', `${basis.acceptedHead}^{tree}`]).trim();
- if (readGit(root, ['rev-parse', `${commit}^{tree}`]).trim() !== tree) return null;
- const merged = readGit(root, ['merge-tree', '--write-tree', '--name-only', '-z', basis.acceptedHead, trunk], [0, 1]).split('\0');
+ if (basis.conflict.trunk) read(['merge-base', '--is-ancestor', basis.conflict.trunk, trunk]);
+ const acceptedTree = read(['rev-parse', `${basis.acceptedHead}^{tree}`]).trim();
+ if (read(['rev-parse', `${commit}^{tree}`]).trim() !== tree) return null;
+ const merged = read(['merge-tree', '--write-tree', '--name-only', '-z', basis.acceptedHead, trunk], [0, 1]).split('\0');
const mergeTree = merged.shift();
if (!/^[a-f0-9]{40,64}$/u.test(mergeTree)) return null;
const conflicts = merged.slice(0, merged.indexOf(''));
- const changed = readGit(root, ['diff', '--no-ext-diff', '--no-textconv', '--no-renames', '--name-only', '-z', mergeTree, tree, '--']).split('\0').filter(Boolean);
+ const changed = read(['diff', '--no-ext-diff', '--no-textconv', '--no-renames', '--name-only', '-z', mergeTree, tree, '--']).split('\0').filter(Boolean);
+ if (changed.length > 32 || conflicts.length > 32 || basis.cleanOnly && (conflicts.length || changed.length)) return null;
+ if (conflicts.some(path => !changed.includes(path))) return null;
for (const path of changed) {
if (!conflicts.includes(path) || !basis.conflict.files.includes(path)) return null;
- const auto = readGit(root, ['ls-tree', '-z', mergeTree, '--', path]);
- const actual = readGit(root, ['ls-tree', '-z', tree, '--', path]);
+ const auto = read(['ls-tree', '-z', mergeTree, '--', path]);
+ const actual = read(['ls-tree', '-z', tree, '--', path]);
if (!/^100(?:644|755) blob /u.test(auto) || auto.slice(0, 6) !== actual.slice(0, 6)) return null;
- const source = readGit(root, ['show', `${mergeTree}:${path}`]);
+ const source = read(['show', `${mergeTree}:${path}`]);
if (source.includes('\0')) return null;
- const patch = readGit(root, ['diff', '--no-ext-diff', '--no-textconv', '--no-renames', '--unified=0', mergeTree, tree, '--', path]);
+ if (/^(?:<<<<<<<|=======|>>>>>>>)/mu.test(read(['show', `${tree}:${path}`]))) return null;
+ const patch = read(['diff', '--no-ext-diff', '--no-textconv', '--no-renames', '--unified=0', mergeTree, tree, '--', path]);
if (!conflictEditsOnly(source, patch, basis.acceptedHead, trunk)) return null;
}
- const resolutionDiff = readGit(root, ['diff', '--no-ext-diff', '--no-textconv', '--no-renames', mergeTree, tree, '--']);
+ const resolutionDiff = read(['diff', '--no-ext-diff', '--no-textconv', '--no-renames', mergeTree, tree, '--']);
if (resolutionDiff.length > 1024 * 1024) return null;
- const paths = [...new Set([...(basis.review?.paths ?? []), ...readGit(root,
+ const paths = [...new Set([...(basis.review?.paths ?? []), ...read(
['diff', '--no-renames', '--name-only', '-z', trunk, commit, '--']).split('\0').filter(Boolean)])].sort();
return { version: 1, acceptedCommit: basis.acceptedCommit, acceptedHead: basis.acceptedHead,
acceptedTree, commit, tree, trunk, mergeTree, digest: basis.digest, verdict: basis.verdict,
diff --git a/src/merge-only-verdict.js b/src/merge-only-verdict.js
index 92e81d8c..e3240625 100644
--- a/src/merge-only-verdict.js
+++ b/src/merge-only-verdict.js
@@ -9,7 +9,7 @@ export function mergeOnlyBasis(board, item) {
const last = board.db.prepare("SELECT event_id, event_kind, event_detail FROM event WHERE item_id = ? AND event_kind IN ('reopen','accept','reject','refreeze','merge-only-accept') ORDER BY event_id DESC LIMIT 1").get(item.item_id);
if (last?.event_kind !== 'reopen') return null;
const returned = JSON.parse(last.event_detail);
- if (!returned.conflict || !Number.isSafeInteger(returned.supersedes)) return null;
+ if ((!returned.conflict && !returned.landingFailure) || !Number.isSafeInteger(returned.supersedes)) return null;
const accepted = board.db.prepare("SELECT event_detail FROM event WHERE event_id = ? AND item_id = ? AND event_kind IN ('accept','merge-only-accept')").get(returned.supersedes, item.item_id);
if (!accepted) return null;
const detail = JSON.parse(accepted.event_detail);
@@ -17,7 +17,8 @@ export function mergeOnlyBasis(board, item) {
if (!verdict || verdict.verdict_digest !== item.item_frozen_digest || detail.commit !== returned.commit || item.item_commit !== returned.commit) return null;
return { acceptedCommit: returned.commit, acceptedHead: verdict.review?.head ?? returned.commit,
digest: item.item_frozen_digest, verdict: verdict.verdict_id, by: verdict.verdict_by,
- reopen: last.event_id, conflict: returned.conflict, review: verdict.review ?? null };
+ reopen: last.event_id, conflict: returned.conflict ?? { trunk: null, files: [] },
+ cleanOnly: !returned.conflict, review: verdict.review ?? null };
}
/** Validate sealed source facts against native history without consulting replica-local Git. */
diff --git a/src/moves/reopen.js b/src/moves/reopen.js
index 14d48ba8..9639b215 100644
--- a/src/moves/reopen.js
+++ b/src/moves/reopen.js
@@ -1,4 +1,5 @@
import { VERDICT_WITHDRAW_ENGINE } from '../verdict-withdraw-engine.js';
+import { MERGE_ONLY_VERDICT_ENGINE } from '../merge-only-verdict-engine.js';
import { RIGOR_AUTO_ENGINE } from '../rigor-auto-engine.js';
/** Routing metadata owned by reopen, discovered without a shared registry edit [C7,V4,H16]. */
import { itemById } from '../board-item-read.js';
@@ -29,7 +30,9 @@ function existingEngine(args, board, at) {
/** Keep verdict withdrawal as an independent maximum over every prior first-match floor [H16]. */
function minimumEngine(args, board, at) {
- return Math.max(args[1]?.withdrawVerdict === true ? VERDICT_WITHDRAW_ENGINE : 1, existingEngine(args, board, at));
+ const carried = board && board.db.prepare("SELECT 1 FROM item i JOIN event e ON e.item_id = i.item_id WHERE i.item_id = ? AND e.event_kind = 'merge-only-accept' AND json_extract(e.event_detail,'$.commit') = i.item_commit LIMIT 1").get(args[0]);
+ return Math.max(carried ? MERGE_ONLY_VERDICT_ENGINE : 1,
+ args[1]?.withdrawVerdict === true ? VERDICT_WITHDRAW_ENGINE : 1, existingEngine(args, board, at));
}
/** Read precisely the actor argument used by this operation [H2,H16]. */
diff --git a/src/verdict-withdrawal.js b/src/verdict-withdrawal.js
index a745aa84..97df7a4c 100644
--- a/src/verdict-withdrawal.js
+++ b/src/verdict-withdrawal.js
@@ -1,6 +1,8 @@
/** Append-only withdrawal bindings and derived review-history annotations [V2,V6,H16]. */
import { Refused } from './refused.js';
import { VERDICT_WITHDRAW_ENGINE } from './verdict-withdraw-engine.js';
+import { ENGINE_VERSION } from './engine-metadata.js';
+import { MERGE_ONLY_VERDICT_ENGINE } from './merge-only-verdict-engine.js';
/** Pair immutable verdict rows with their corresponding immutable acceptance/rejection events. */
function verdictPairs(board, id) {
@@ -31,8 +33,9 @@ export function verdictWithdrawals(board, id) {
export function verdictWithdrawalTarget(board, item, agentId) {
if (item.item_status !== 'verified') throw new Refused('VERDICT_WITHDRAW_STATE', 'withdraw an accepted, unmerged item; use ordinary reopen for a submitted item');
const withdrawn = verdictWithdrawals(board, item.item_id);
- const carry = board.db.prepare("SELECT event_detail FROM event WHERE item_id = ? AND event_kind = 'merge-only-accept' AND json_extract(event_detail,'$.commit') = ? ORDER BY event_id DESC LIMIT 1")
- .get(item.item_id, item.item_commit);
+ const carry = (board.executionEngineVersion ?? ENGINE_VERSION) >= MERGE_ONLY_VERDICT_ENGINE
+ ? board.db.prepare("SELECT event_detail FROM event WHERE item_id = ? AND event_kind = 'merge-only-accept' AND json_extract(event_detail,'$.commit') = ? ORDER BY event_id DESC LIMIT 1")
+ .get(item.item_id, item.item_commit) : null;
const carriedVerdict = carry ? JSON.parse(carry.event_detail).verdict : null;
const pair = verdictPairs(board, item.item_id).findLast(({ verdict, event }) => verdict.verdict_decision === 'ACCEPT'
&& (verdict.verdict_commit === item.item_commit || verdict.verdict_id === carriedVerdict)
diff --git a/test/machine.test.js b/test/machine.test.js
index 42a6407a..676a349b 100644
--- a/test/machine.test.js
+++ b/test/machine.test.js
@@ -1329,7 +1329,7 @@ test('the lifecycle page and the help show the reservation: reserve, and reviewF
assert.match(page, /^\| reserve \| submitted \| submitted \| agent, coordinator \| .*reviewFree \(REVIEW_HELD\) \|$/m);
for (const verb of ['accept', 'reject']) assert.match(page, new RegExp(`^\\| ${verb} \\| submitted, verified \\| .*policyAllows \\(COORDINATOR_VERIFIES\\), familyAllows \\(O2_FAMILY_MATCH\\), reviewFree \\(REVIEW_HELD\\), criterionUnchanged`, 'm'));
assert.match(page, /^\| REVIEW_HELD \| no other agent holds its review under a live lease \| pullboard next --verify/m);
- assert.match(HELP.all, /^ {2}agent +intake, claim, release, submit, reserve, accept, reject, reopen, escalate, refreeze \(when a live claim has a pending coordinator correction\)$/m);
+ assert.match(HELP.all, /^ {2}agent +intake, claim, release, submit, reserve, accept, reject, reopen, escalate, submit-merge \(when only an unchanged accepted bar and a proved trunk-only merge; no new reviewer verdict is created\), refreeze \(when a live claim has a pending coordinator correction\)$/m);
assert.match(HELP.all, /pullboard next --verify +reserve the next submitted item you can check/);
});
diff --git a/test/merge-only-verdict.test.js b/test/merge-only-verdict.test.js
index 0f639856..ab7d9078 100644
--- a/test/merge-only-verdict.test.js
+++ b/test/merge-only-verdict.test.js
@@ -8,6 +8,9 @@ import * as store from '../src/board.js';
import { createE2eHelpers } from './e2e-helpers.js';
import { captureMergeOnly } from '../src/merge-only-source.js';
import { runFixtureGit, runFixtureChild } from './fixture-child.js';
+import { exportBoard, importBoard } from '../src/exchange.js';
+import { prepareEngineMove, applyEngineMove } from '../src/engine.js';
+import { MERGE_ONLY_VERDICT_ENGINE } from '../src/merge-only-verdict-engine.js';
const e2e = createE2eHelpers();
after(e2e.cleanup);
@@ -24,7 +27,7 @@ function state(box, id) {
const board = store.openBoard(join(box.repo, '.git', 'pullboard', 'board.sqlite'));
try {
return { item: store.getItem(board, id), verdicts: store.verdictsFor(board, id),
- events: store.events(board, { itemId: id }) };
+ events: store.events(board, { itemId: id }), snapshot: exportBoard(board) };
} finally { store.closeBoard(board); }
}
@@ -59,6 +62,7 @@ test('a merge-only resubmission keeps its accept and records the resolution diff
assert.notEqual(box.tryGit(box.web, 'merge', '-q', '--no-edit', 'main').status, 0);
const head = content(box, box.web, 'resolved', 'fix(web): resolve the accepted trunk merge [G1]');
assert.deepEqual(box.git(box.web, 'show', '-s', '--format=%P', head).split(' '), [accepted, trunk]);
+ const pending = state(box, id);
succeeds(box, box.web, 'submit', String(id));
const carried = state(box, id);
assert.equal(carried.item.item_status, 'verified', 'a gated merge-only resubmission keeps its original acceptance');
@@ -78,6 +82,42 @@ test('a merge-only resubmission keeps its accept and records the resolution diff
const shown = succeeds(box, box.repo, 'show', String(id));
assert.match(shown.out, /verified/u);
assert.doesNotMatch(shown.out, /re-review: main merge only/u);
+ const submitted = JSON.parse(carried.events.findLast(event => event.event_kind === 'submit').event_detail);
+ const options = { agentId: pending.item.item_owner, commit: head, tree: submitted.tree,
+ policyCommit: submitted.policyCommit, submissionProof: submitted.submissionProof, mergeOnly: detail };
+ for (const key of ['commit', 'tree', 'trunk', 'acceptedHead', 'digest', 'verdict', 'reopen']) {
+ const replica = store.openBoard(':memory:');
+ try {
+ importBoard(replica, pending.snapshot);
+ const bad = { ...detail, [key]: typeof detail[key] === 'number' ? detail[key] + 100 : '0'.repeat(40) };
+ assert.throws(() => store.submit(replica, id, { ...options, mergeOnly: bad }), error => error.code === 'MERGE_ONLY_PROOF', key);
+ assert.equal(store.getItem(replica, id).item_status, 'claimed', 'invalid proof is atomic');
+ assert.equal(store.events(replica, { itemId: id }).filter(event => event.event_kind === 'merge-only-accept').length, 0);
+ } finally { store.closeBoard(replica); }
+ }
+ const refrozen = store.openBoard(':memory:');
+ try {
+ importBoard(refrozen, pending.snapshot);
+ store.refreeze(refrozen, id, { agentId: 'coordinator', freeze: () => ({ text: pending.item.item_frozen, digest: 'a different frozen bar' }) });
+ store.claim(refrozen, id, { agentId: options.agentId, lane: 'web', leaseMs: 7_200_000,
+ freeze: () => ({ text: pending.item.item_frozen, digest: 'a different frozen bar' }) });
+ assert.throws(() => store.submit(refrozen, id, options), error => error.code === 'MERGE_ONLY_PROOF');
+ assert.equal(store.events(refrozen, { itemId: id }).filter(event => event.event_kind === 'merge-only-accept').length, 0);
+ } finally { store.closeBoard(refrozen); }
+ const replay = store.openBoard(':memory:');
+ try {
+ importBoard(replay, pending.snapshot);
+ const move = prepareEngineMove(replay, 'submit', [id, options]);
+ assert.throws(() => applyEngineMove(replay, { ...move, engine: MERGE_ONLY_VERDICT_ENGINE - 1 },
+ { sequence: 1, at: '2026-01-01T00:00:00.000Z' }), /engine/iu);
+ applyEngineMove(replay, move, { sequence: 1, at: '2026-01-01T00:00:00.000Z' });
+ assert.equal(store.getItem(replay, id).item_status, 'verified');
+ assert.equal(store.acceptedVerdict(replay, store.getItem(replay, id)).verdict_id, detail.verdict);
+ assert.equal(store.checkedLandingCommit(replay, store.getItem(replay, id)), head);
+ store.reopen(replay, id, { agentId: 'coordinator', withdrawVerdict: true, note: 'the original reviewer withdraws the retained acceptance' });
+ assert.equal(store.getItem(replay, id).item_status, 'open');
+ assert.equal(store.acceptedVerdict(replay, store.getItem(replay, id)), undefined, 'a carry cannot resurrect a withdrawn original verdict');
+ } finally { store.closeBoard(replay); }
});
/** Make a small real Git conflict without pretending these synthetic identities are live reviewers. */
@@ -106,7 +146,9 @@ function sourceFixture(t) {
/** Capture the exact current commit and tree as the post-gate CLI does. */
const capture = () => captureMergeOnly(root, basis, { commit: git('rev-parse', 'HEAD'),
tree: git('rev-parse', 'HEAD^{tree}'), trunk });
- return { root, git, save, accepted, trunk, commit, basis, capture };
+ /** Start a real conflict with the same isolated Git identity and configuration as every fixture write. */
+ const conflict = () => runFixtureChild('git', ['merge', '-q', '--no-edit', 'main'], { cwd: root, env, encoding: 'utf8', timeout: 5000 });
+ return { root, git, save, accepted, trunk, commit, basis, capture, conflict };
}
test('extra behavioral edits in the same conflicted file need outside review [V1,V4]', t => {
@@ -125,3 +167,32 @@ test('amended non-merge and stale head or tree proofs cannot retain an accept [V
box.save('resolved', 'unchanged', true);
assert.equal(box.capture(), null, 'an amended commit without the exact merge parents needs review');
});
+
+test('unresolved conflict markers cannot masquerade as a resolution [V1,V4]', t => {
+ const box = sourceFixture(t);
+ box.git('reset', '--hard', box.accepted);
+ const merged = box.conflict();
+ assert.notEqual(merged.status, 0);
+ assert.match(merged.stdout, /CONFLICT/u);
+ box.git('add', 'hot.js'); box.git('commit', '-q', '-m', 'unresolved markers');
+ assert.equal(box.capture(), null);
+});
+
+test('a landing-failure return allows only the exact automatic clean merge [V1,V4]', t => {
+ const box = sourceFixture(t);
+ box.git('switch', '-q', 'main'); box.git('reset', '--hard', `${box.accepted}^`);
+ writeFileSync(join(box.root, 'trunk-only.txt'), 'accepted trunk change\n');
+ box.git('add', 'trunk-only.txt'); box.git('commit', '-q', '-m', 'trunk-only change');
+ const trunk = box.git('rev-parse', 'HEAD');
+ box.git('switch', '-q', 'candidate'); box.git('reset', '--hard', box.accepted);
+ box.git('merge', '-q', '--no-edit', 'main');
+ const basis = { ...box.basis, cleanOnly: true, conflict: { trunk: null, files: [] } };
+ const commit = box.git('rev-parse', 'HEAD');
+ const tree = box.git('rev-parse', 'HEAD^{tree}');
+ const proof = captureMergeOnly(box.root, basis, { commit, tree, trunk });
+ assert.ok(proof);
+ assert.equal(proof.resolutionDiff, '', 'no unrecorded conflict resolution is exempt');
+ box.save('accepted', 'extra behavior', true);
+ assert.equal(captureMergeOnly(box.root, basis, { commit: box.git('rev-parse', 'HEAD'),
+ tree: box.git('rev-parse', 'HEAD^{tree}'), trunk }), null);
+});