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.

perf(core): bound status history and repeated board reads [C7]

Corey Olson8b176dc25809
diff --git a/src/board-hot.js b/src/board-hot.js
index ced76d7f..8c44bddd 100644
--- a/src/board-hot.js
+++ b/src/board-hot.js
@@ -37,6 +37,44 @@ export function eventsOfKinds(board, kinds) {
return board.db.prepare(`SELECT * FROM event WHERE event_kind IN (${kinds.map(() => '?').join(', ')}) ORDER BY event_id`).all(...kinds);
}
+/**
+ * Read landing evidence and only the exact submissions a failed gate names. Proposals need no
+ * unrelated submission history, and a board with no failed landing needs no submission rows.
+ * Keep every landing snapshot in order: later green gates/diagnostics still clear earlier reds,
+ * while repeated evidence keeps the original ordering rules in submitInvariantProposals.
+ */
+export function submitInvariantEvents(board, config) {
+ if (config.submitGate !== 'landing') return [];
+ const landings = eventsOfKinds(board, ['landing_batch']);
+ const needed = new Map();
+ for (const event of landings) {
+ const detail = JSON.parse(event.event_detail);
+ for (const gate of detail.batch?.invariantEvidence?.gates ?? []) {
+ if (gate.isGreen || !gate.failures.length) continue;
+ for (const row of gate.submissions) needed.set(`${row.id}:${row.commit}`, row);
+ }
+ }
+ if (!needed.size) return [];
+ const submissions = [];
+ const history = board.db.prepare("SELECT * FROM event WHERE item_id=? AND event_kind='submit' ORDER BY event_id DESC");
+ const remaining = new Map();
+ for (const { id, commit } of needed.values()) {
+ const commits = remaining.get(id) ?? new Set();
+ commits.add(commit);
+ remaining.set(id, commits);
+ }
+ for (const [id, commits] of remaining) {
+ for (const event of history.iterate(id)) {
+ const detail = JSON.parse(event.event_detail);
+ if (!commits.has(detail.commit) || !detail.submissionProof) continue;
+ submissions.push(event);
+ commits.delete(detail.commit);
+ if (!commits.size) break;
+ }
+ }
+ return [...landings, ...submissions].sort((a, b) => a.event_id - b.event_id);
+}
+
/**
* The newest events, newest first. The id bound states the range read, so the plan seeks from the
* end of the log rather than scanning it.
diff --git a/src/board-stats.js b/src/board-stats.js
index 6ea15df0..6f926b33 100644
--- a/src/board-stats.js
+++ b/src/board-stats.js
@@ -1,5 +1,4 @@
/** Item status and verdict totals for board summaries. */
-import { listItems } from './board.js';
/**
* Counts for the status line and the ledger's summary: items by status, verdicts by decision.
@@ -9,7 +8,9 @@ import { listItems } from './board.js';
*/
export function stats(board) {
const items = { open: 0, claimed: 0, submitted: 0, verified: 0, withdrawn: 0 };
- for (const item of listItems(board, { all: true })) items[item.item_status] += 1;
+ const counts = board.db.prepare(`SELECT CASE WHEN item_status='claimed' AND COALESCE(item_lease_until,'')<=?
+ THEN 'open' ELSE item_status END AS status, COUNT(*) AS total FROM item GROUP BY status`).all(board.clock.now().toISOString());
+ for (const row of counts) items[row.status] = row.total;
const verdicts = board.db
.prepare('SELECT verdict_decision AS decision, COUNT(*) AS total FROM verdict GROUP BY verdict_decision')
.all();
diff --git a/src/board.js b/src/board.js
index e6582620..a73c79db 100644
--- a/src/board.js
+++ b/src/board.js
@@ -136,7 +136,7 @@ export { flakeLedger, recordFlakeObservation } from './flakes.js';
export { flakeQuarantines, gateRuns, recordGateRun } from './quarantine.js';
/** The seat readers live in seats.js; the board re-exports them so `store.*` callers keep one import. */
-export { agentAt, agentCreator, coordinatorHolder, listAgents, nextSeatId, seatEnrolled, seatLineage, takeCoordinator, withVerifierStanding } from './seats.js';
+export { agentAt, agentById, agentCreator, coordinatorHolder, listAgents, nextSeatId, seatEnrolled, seatLineage, takeCoordinator, withVerifierStanding } from './seats.js';
export const ACCEPT_REASON = 'CRITERION_MET';
export const PERSON = 'person';
@@ -1434,7 +1434,7 @@ export function reviewQueueBreakdown(board) {
let awaitingFirstReview = 0;
let releasedWithoutVerdict = 0;
const releasedItems = [];
- for (const item of listItems(board).filter((entry) => entry.item_status === 'submitted' && !reviewHolder(board, entry))) {
+ for (const item of itemsInStatus(board, 'submitted').filter((entry) => !reviewHolder(board, entry))) {
const releases = reviewReleasesSinceSubmit(board, item.item_id);
if (releases.length) {
releasedWithoutVerdict += 1;
@@ -1446,11 +1446,12 @@ export function reviewQueueBreakdown(board) {
/** Summarize outstanding reviews using live leases and the latest submission's age [Q1,V15]. */
export function reviewQueue(board) {
- const pending = listItems(board).filter((item) => item.item_status === 'submitted');
+ const pending = itemsInStatus(board, 'submitted');
const holders = pending.map((item) => reviewHolder(board, item)).filter(Boolean);
- const submissions = new Map(board.db.prepare("SELECT item_id, MAX(event_at) AS submitted_at FROM event WHERE event_kind='submit' GROUP BY item_id")
- .all().map((event) => [event.item_id, event.submitted_at]));
- const oldestSubmittedAt = pending.map((item) => submissions.get(item.item_id)).filter(Boolean).sort()[0] ?? null;
+ // Only the current queue needs an age. Seek each item's history, including legacy timestamps,
+ // instead of grouping every submission ever made on the board.
+ const submittedAt = board.db.prepare("SELECT MAX(event_at) AS at FROM event WHERE item_id=? AND event_kind='submit'");
+ const oldestSubmittedAt = pending.map((item) => submittedAt.get(item.item_id).at).filter(Boolean).sort()[0] ?? null;
return { pending: pending.length, reviewing: new Set(holders).size, reserved: holders.length, oldestSubmittedAt,
ageMs: oldestSubmittedAt ? Math.max(0, board.clock.now().getTime() - Date.parse(oldestSubmittedAt)) : 0 };
}
@@ -1848,11 +1849,18 @@ export function pendingRefreezeProblem(board, id) {
* @returns {any[]}
*/
export function listItems(board, { lane, all = false } = {}) {
+ const hasLane = lane !== undefined && lane !== null;
const rows = board.db
- .prepare('SELECT * FROM item WHERE (? IS NULL OR item_lane = ?) ORDER BY item_id DESC')
- .all(lane ?? null, lane ?? null);
+ .prepare(`SELECT * FROM item WHERE ${all ? '1' : "item_status NOT IN ('verified','withdrawn')"}${hasLane ? ' AND item_lane=?' : ''} ORDER BY item_id DESC`)
+ .all(...(hasLane ? [lane] : []));
const items = rows.map((item) => current(board, item));
- return all ? items : items.filter((item) => !['verified', 'withdrawn'].includes(item.item_status));
+ return items;
+}
+
+/** Read a stored status/owner slice, excluding claims whose leases have expired rather than caching items. */
+export function itemsInStatus(board, status, owner = null) {
+ return board.db.prepare(`SELECT * FROM item WHERE item_status=?${owner === null ? '' : ' AND item_owner=?'} ORDER BY item_id DESC`)
+ .all(status, ...(owner === null ? [] : [owner])).map(item => current(board, item)).filter(item => item.item_status === status);
}
/** Return all recorded submitted heads of items still awaiting verification [V1,V17].
@@ -2663,7 +2671,7 @@ export function peekShouts(board, agentId, limit = 2) {
.reverse();
}
-export { recentShouts, eventsOfKinds, recentEvents, lastMoves, decisionAndEvidenceShouts } from './board-hot.js';
+export { recentShouts, eventsOfKinds, recentEvents, lastMoves, decisionAndEvidenceShouts, submitInvariantEvents } from './board-hot.js';
export { stats } from './board-stats.js';
diff --git a/src/cli.js b/src/cli.js
index ce81c431..1c87246c 100644
--- a/src/cli.js
+++ b/src/cli.js
@@ -1036,7 +1036,7 @@ export function whoAmI(ctx, board) {
if (seat) return { id: seat.agent_id, lane: seat.agent_lane, route: seat.agent_route, family: seat.agent_family ?? null, model: seat.agent_model ?? 'unknown', displayName: displayAgentName(seat, ctx.config.agents.names) };
if (ctx.info.isMain) {
ctx.io.caller?.('coordinator', ctx.info.root);
- const registered = store.listAgents(board).find((agent) => agent.agent_id === COORDINATOR);
+ const registered = store.agentById(board, COORDINATOR);
const linked = relayLinked(ctx.info.root);
if (linked && !registered) throw new Refused('NO_AGENT', 'the linked snapshot has no coordinator; restore a consistent relay snapshot before acting');
const id = linked ? COORDINATOR : store.ensureCoordinator(board, ctx.info.root);
diff --git a/src/commands/list.js b/src/commands/list.js
index 0271f8bd..1070d398 100644
--- a/src/commands/list.js
+++ b/src/commands/list.js
@@ -16,10 +16,11 @@ import {
/** Run `pullboard list` and return its exit code. */
export function run(io, { first, values }) {
const ctx = context(io);
- const { items, agents, merging } = withBoard(ctx, (board) => ({
- items: store.listItems(board, { lane: first, all: values.all }).map(verdictProjector(ctx.info.root, board).project),
- agents: store.listAgents(board), merging: new Set(store.listItems(board, { lane: first }).filter((item) => mainMergeFor(board, item.item_id)).map((item) => item.item_id)),
- }));
+ const { items, agents, merging } = withBoard(ctx, (board) => {
+ const rows = store.listItems(board, { lane: first, all: values.all });
+ return { items: rows.map(verdictProjector(ctx.info.root, board).project), agents: store.listAgents(board),
+ merging: new Set(rows.filter(item => !['verified', 'withdrawn'].includes(item.item_status) && mainMergeFor(board, item.item_id)).map(item => item.item_id)) };
+ });
const filtered = items.filter((item) => !values.route || item.item_route === values.route);
if (values.json) io.result({ items: filtered });
else if (!filtered.length) io.say(values.all ? 'no items yet' : 'nothing open; --all shows closed items');
diff --git a/src/commands/status.js b/src/commands/status.js
index cbc93481..04825d5b 100644
--- a/src/commands/status.js
+++ b/src/commands/status.js
@@ -32,10 +32,10 @@ export function run(io, { values }) {
const ctx = context(io);
const summary = withBoard(ctx, (board) => {
const me = whoAmI(ctx, board);
- const mine = store.listItems(board).filter((item) => item.item_status === 'claimed' && item.item_owner === me.id);
+ const mine = store.itemsInStatus(board, 'claimed', me.id);
const approvalState = personNeedsSummary(ctx.info.root, { board, config: ctx.config });
return { me, mine, needs: approvalState.needs, specApprovalBaseline: approvalState.specApprovalBaseline, specApprovalEvidenceErrors: approvalState.specApprovalEvidenceErrors, stats: store.stats(board), reviewQueue: { ...store.reviewQueue(board), ...store.reviewQueueBreakdown(board) }, unread: store.unreadCount(board, me.id), relay: relayStatus(ctx.info.root),
- submitInvariantProposals: submitInvariantProposals(store.eventsOfKinds(board, ['submit', 'landing_batch']), ctx.config) };
+ submitInvariantProposals: submitInvariantProposals(store.submitInvariantEvents(board, ctx.config), ctx.config) };
});
if (values.json) {
io.result(summary);
diff --git a/src/seats.js b/src/seats.js
index 8a06477e..ddf2a693 100644
--- a/src/seats.js
+++ b/src/seats.js
@@ -26,6 +26,11 @@ export function agentAt(board, path) {
return withModel(board, agent);
}
+/** Read one seat and its model without loading every registered seat and model on the board. */
+export function agentById(board, id) {
+ return withModel(board, board.db.prepare('SELECT * FROM agent WHERE agent_id = ?').get(id));
+}
+
/** Read the model label kept beside other board metadata, avoiding any board-schema migration. */
export function agentModel(board, id) {
return board.db.prepare('SELECT meta_value FROM board_meta WHERE meta_key = ?').get(`agent_model:${id}`)?.meta_value ?? null;
@@ -53,7 +58,8 @@ export function saveAgentModel(board, id, model) {
* @returns {any[]}
*/
export function listAgents(board) {
- return board.db.prepare('SELECT * FROM agent ORDER BY rowid').all().map((agent) => withModel(board, agent));
+ return board.db.prepare(`SELECT agent.*, board_meta.meta_value AS agent_model FROM agent
+ LEFT JOIN board_meta ON board_meta.meta_key='agent_model:' || agent.agent_id ORDER BY agent.rowid`).all().map(agent => ({ ...agent }));
}
/**
diff --git a/test/board.test.js b/test/board.test.js
index 1186e1ac..655341ce 100644
--- a/test/board.test.js
+++ b/test/board.test.js
@@ -684,6 +684,21 @@ test('every move lands in the event log; stats count items and verdicts [R1, R2]
assert.equal(stats.rejected, 1);
});
+test('summary reads expire a held claim at its deadline without changing its stored owner [B4,R1]', () => {
+ const id = store.addItem(board, { by: 'coordinator', lane: 'web', title: 'A short claim' });
+ claimAs(id, 'web-1', 'web');
+ assert.equal(store.stats(board).items.claimed, 1);
+ assert.equal(store.itemsInStatus(board, 'claimed', 'web-1')[0].item_id, id);
+ assert.equal(store.itemsInStatus(board, 'claimed', 'web-2').length, 0);
+ clock.advance(2 * HOUR);
+ assert.deepEqual(store.stats(board).items, { open: 1, claimed: 0, submitted: 0, verified: 0, withdrawn: 0 });
+ assert.deepEqual(store.itemsInStatus(board, 'claimed', 'web-1'), []);
+ assert.equal(store.getItem(board, id).item_status, 'open');
+ const stored = board.db.prepare('SELECT item_status, item_owner FROM item WHERE item_id=?').get(id);
+ assert.equal(stored.item_status, 'claimed');
+ assert.equal(stored.item_owner, 'web-1');
+});
+
test('an item can wait on others: claiming it is refused until they are verified [B8]', () => {
const contract = store.addItem(board, { by: 'coordinator', lane: 'web', title: 'Store module' });
const user = store.addItem(board, { by: 'coordinator', lane: 'api', title: 'Uses the store', after: [contract] });
diff --git a/test/cli-read-performance.test.js b/test/cli-read-performance.test.js
new file mode 100644
index 00000000..4fd42471
--- /dev/null
+++ b/test/cli-read-performance.test.js
@@ -0,0 +1,110 @@
+/** Real in-process CLI reads on a private board at the measured production scale [C7]. */
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtempSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir, loadavg, cpus } from 'node:os';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { test } from 'node:test';
+import { main } from '../src/cli.js';
+import * as store from '../src/board.js';
+import { runFixtureGit } from './fixture-child.js';
+import { submitFixture } from './board-submit-fixture.js';
+
+/** Capture one complete production command, including its JSON serialization and fresh Git scope. */
+async function command(root, argv) {
+ let stdout = '', stderr = '';
+ const started = performance.now();
+ const code = await main([...argv, '--json'], { cwd: root,
+ stdout: { isTTY: false, write(text) { stdout += text; } },
+ stderr: { write(text) { stderr += text; } } });
+ const ms = performance.now() - started;
+ assert.equal(code, 0, stderr || stdout);
+ return { ms, data: JSON.parse(stdout), stderr };
+}
+
+/** Seed real rows, not cached command results, with many historical submissions and a small live queue. */
+function fixture(t) {
+ const root = realpathSync(mkdtempSync(join(tmpdir(), 'pullboard-cli-read-performance-')));
+ let db;
+ t.after(() => { db?.close(); rmSync(root, { recursive: true, force: true }); });
+ const env = { ...process.env, GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1',
+ GIT_AUTHOR_NAME: 'Performance fixture', GIT_AUTHOR_EMAIL: '[email protected]',
+ GIT_COMMITTER_NAME: 'Performance fixture', GIT_COMMITTER_EMAIL: '[email protected]' };
+ runFixtureGit(['init', '-q', '-b', 'main'], { cwd: root, env });
+ writeFileSync(join(root, 'pullboard.json'), JSON.stringify({ gate: 'true', submitGate: 'landing',
+ lanes: { core: { owns: ['src/'], specs: ['C7'] } }, spec: 'SPEC.md' }));
+ writeFileSync(join(root, 'SPEC.md'), '# Performance fixture\n## C\n- C7 [approved, must] Reads preserve the board. | gate: test\n');
+ writeFileSync(join(root, 'PRACTICE.md'), '');
+ runFixtureGit(['add', '-A'], { cwd: root, env });
+ runFixtureGit(['commit', '-qm', 'Seed performance fixture'], { cwd: root, env });
+ const file = join(root, '.git', 'pullboard', 'board.sqlite');
+ const board = store.openBoard(file);
+ store.register(board, { lane: 'coordinator', path: root });
+ store.closeBoard(board);
+ db = new DatabaseSync(file);
+ const at = '2026-10-23T00:00:00.000Z';
+ db.exec('BEGIN');
+ const agent = db.prepare('INSERT INTO agent (agent_id, agent_lane, agent_path, agent_created_at) VALUES (?, ?, ?, ?)');
+ for (let n = 1; n <= 800; n++) agent.run(`core-${n}`, 'core', join(root, 'seats', String(n)), at);
+ const item = db.prepare(`INSERT INTO item (item_lane, item_title, item_criterion, item_status,
+ item_created_by, item_created_at, item_updated_at) VALUES ('core', ?, 'The read preserves evidence.', ?, 'coordinator', ?, ?)`);
+ for (let n = 1; n <= 1000; n++) item.run(`Item ${n}`, 'open', at, at);
+ const event = db.prepare('INSERT INTO event (event_at, event_by, event_kind, item_id, event_detail) VALUES (?, ?, ?, ?, ?)');
+ const commit = 'a'.repeat(40);
+ const proof = JSON.stringify({ commit, submissionProof: { version: 1, files: ['test/a.test.js'], full: false, deferred: false, reason: 'affected selection' } });
+ for (let n = 0; n < 45000; n++) event.run(at, `core-${1 + n % 800}`, n % 3 === 0 ? 'submit' : n % 3 === 1 ? 'claim' : 'edit', 1 + n % 1000, n % 3 === 0 ? proof : '{}');
+ const shout = db.prepare('INSERT INTO shout (shout_from, shout_to, shout_text, shout_at) VALUES (?, ?, ?, ?)');
+ for (let n = 0; n < 23000; n++) shout.run(`core-${1 + n % 800}`, 'all', `Board activity ${n}`, at);
+ db.exec('COMMIT');
+ const live = store.openBoard(file);
+ try {
+ for (let id = 1; id <= 10; id++) {
+ store.claim(live, id, { agentId: `core-${id}`, lane: 'core', leaseMs: 3_600_000,
+ freeze: () => ({ text: JSON.stringify({ rows: [] }), digest: 'performance-fixture' }) });
+ submitFixture(live, id, { agentId: `core-${id}`, commit, tree: 'b'.repeat(40) });
+ }
+ } finally { store.closeBoard(live); }
+ return { root, db };
+}
+
+/** Hash every persistent table outside the timed region, so a read cannot silently change board state. */
+function boardDigest(db) {
+ const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all();
+ const rows = tables.map(({ name }) => [name, db.prepare(`SELECT * FROM "${name.replaceAll('"', '""')}" ORDER BY rowid`).all()]);
+ return createHash('sha256').update(JSON.stringify(rows)).digest('hex');
+}
+
+test('status show and list each have a five-run in-process median under 100 ms on our board size [C7]', async t => {
+ const { root, db } = fixture(t);
+ const before = boardDigest(db);
+ const events = db.prepare('SELECT COUNT(*) AS n FROM event').get().n;
+ const samples = { status: [], show: [], list: [] };
+ for (let round = 0; round < 5; round++) {
+ for (const name of Object.keys(samples)) {
+ const result = await command(root, name === 'show' ? ['show', '1'] : [name]);
+ samples[name].push(result.ms);
+ if (name === 'status') {
+ assert.equal(result.data.stats.items.submitted, 10);
+ assert.equal(result.data.stats.items.open, 990);
+ assert.equal(result.data.reviewQueue.pending, 10);
+ assert.deepEqual(result.data.submitInvariantProposals, [], 'no failing landing evidence means no proposal');
+ }
+ if (name === 'show') {
+ assert.equal(result.data.item_id, 1);
+ assert.equal(result.data.item_status, 'submitted');
+ assert.ok(result.data.thread.some(entry => entry.kind === 'submit'), 'detail retains submission history');
+ }
+ if (name === 'list') {
+ assert.equal(result.data.items.length, 1000);
+ assert.equal(new Set(result.data.items.map(item => item.item_id)).size, 1000);
+ assert.equal(result.data.items.filter(item => item.item_status === 'submitted').length, 10);
+ assert.equal(result.data.items[0].item_id, 1000, 'list remains newest first');
+ }
+ }
+ }
+ assert.equal(boardDigest(db), before, 'reads change no persistent board rows');
+ const medians = Object.fromEntries(Object.entries(samples).map(([name, values]) => [name, [...values].sort((a, b) => a - b)[2]]));
+ t.diagnostic(JSON.stringify({ samplesMs: samples, mediansMs: medians, node: process.version, cpus: cpus().length, load: loadavg(), items: 1000, events, shouts: 23000 }));
+ for (const [name, median] of Object.entries(medians)) assert.ok(median < 100, `${name} median ${median.toFixed(2)} ms exceeds the declared 100 ms budget`);
+});
diff --git a/test/submit-invariants.test.js b/test/submit-invariants.test.js
index 4a7baec9..9a873f38 100644
--- a/test/submit-invariants.test.js
+++ b/test/submit-invariants.test.js
@@ -12,7 +12,7 @@ import {
prepareEngineMove,
} from '../src/engine.js';
import { exportBoard, importBoard } from '../src/exchange.js';
-import { SUBMISSION_PROOF_ENGINE, landingFileTimes } from '../src/submit-invariants.js';
+import { SUBMISSION_PROOF_ENGINE, landingFileTimes, submitInvariantProposals } from '../src/submit-invariants.js';
import { ENGINE_VERSION } from '../src/machine.js';
import { landingFailures } from '../src/land.js';
import { createE2eHelpers } from './e2e-helpers.js';
@@ -138,6 +138,9 @@ test('a landing escape is proposed as a submit invariant [C7,V4]', async () => {
});
const untouchedConfig = readFileSync(configPath, 'utf8');
const proposals = json(box, box.repo, 'status').submitInvariantProposals;
+ onBoard(box, board => assert.deepEqual(submitInvariantProposals(store.submitInvariantEvents(board, config), config),
+ submitInvariantProposals(store.eventsOfKinds(board, ['submit', 'landing_batch']), config),
+ 'targeted reads preserve repeated snapshots, exact-commit recovery, budgets and latest proof semantics'));
assert.equal(proposals[0].file, 'test/repeated.test.js', 'a repeated escape below budget is first');
const byFile = new Map(proposals.map(proposal => [proposal.file, proposal]));
assert.equal(byFile.get('test/repeated.test.js').escapes, 2);
@@ -175,6 +178,9 @@ test('a landing escape is proposed as a submit invariant [C7,V4]', async () => {
landing(box, 'legacy-unknown', { id: submit.legacy, commit: 'd'.repeat(40), policyCommit: submit.policyCommit }, third,
[{ path: 'test/legacy.test.js', durationMs: 1 }]);
assert.equal(json(box, box.repo, 'status').submitInvariantProposals.some(row => row.file === 'test/legacy.test.js'), false);
+ onBoard(box, board => assert.deepEqual(submitInvariantProposals(store.submitInvariantEvents(board, config), config),
+ submitInvariantProposals(store.eventsOfKinds(board, ['submit', 'landing_batch']), config),
+ 'proofless legacy submissions stay unknown in targeted history reads'));
const fallbackItem = json(box, box.repo, 'add', 'web', 'change a non-module input', '--specs', 'G1',
'--criterion', 'Non-module selection is recorded.', '--check', 'node --test web/page.test.js', '--wait').item.item_id;