Files
stack/packages/bus/tests/decision-route.test.mjs
jason.woltjeandClaude Opus 5.5 2c16d6b932 bus: projects and threads, schema 3d to 3e (row 121, #1615)
Darkwing's row 121 round 2 (agents/darkwing/work/queue-121/r2, base
20d2b5788, manifest 710d5086...e67e9b, 30 files), applied unchanged on
d7ebaa9a5; no commit since the base touches any of the 30 paths. Dewey
asked for changes on round 1 in comment 28591 (F1 to F6) and approved
round 2 in 28615. Landing gate on d7ebaa9a5 plus the candidate: all 24
suites passed, 0 failed.

F6 and Dewey's three round 2 notes are follow-ups (sage-0369, P19 task
311). One of them corrects the packet: BUILD.md says the decision-route
setup's projects key is needed, and Dewey's probe showed project.create
reads it only with repo, so the key is dead setup.

The live bus stays at 3b until Mos's schema window migrates it.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 14:06:05 -05:00

156 lines
7.7 KiB
JavaScript

// Row 133 (#1627, REQ-ASSIST-2): whoever closes a decision messages the raising role, so
// decision.raise refuses a route that can't message the raiser before it stores anything. The route
// is the sender and the raiser the target, under row 120's messaging rules. A within-role decision,
// routed to the raiser's own role, is exempt.
import test from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { fileURLToPath } from 'node:url';
import { Store } from '../src/store.mjs';
import { Broker } from '../src/broker.mjs';
// The assistant's lists come from the shipped role file, as in messaging.test.mjs.
const assistantLists = JSON.parse(
readFileSync(fileURLToPath(new URL('../../../roles/assistant.json', import.meta.url)), 'utf8'),
).messaging;
const options = [
{ key: 'yes', text: 'Allow' },
{ key: 'no', text: 'Decline' },
];
const pusher = { authority: { withinRole: ['message.send'], crossRole: ['git.push.working'] } };
const roles = {
pm: { definition: 'pm', authority: { withinRole: ['message.send'], crossRole: [] } },
chief: { definition: 'chief-of-staff', authority: { withinRole: ['message.send'], crossRole: [] } },
assistant: { definition: 'assistant', authority: { withinRole: ['message.send'], crossRole: [] } },
// Hears from pm, the technical arbiter, but not from the chief of staff, the delivery arbiter.
coder: { definition: 'coder', ...pusher },
// Hears from neither arbiter nor the human, but may send to the human: a reversed check passes it.
warden: { definition: 'warden', ...pusher },
// Hears from the human and both arbiters but sends only to pm: a reversed check refuses it.
scribe: { definition: 'scribe', ...pusher },
};
const definitions = {
pm: {},
'chief-of-staff': {},
assistant: { messaging: assistantLists },
coder: { messaging: { sendTo: ['human', 'pm', 'chief-of-staff'], receiveFrom: ['human', 'pm'] } },
warden: { messaging: { sendTo: ['human', 'pm', 'chief-of-staff'], receiveFrom: ['coder'] } },
scribe: { messaging: { sendTo: ['pm'], receiveFrom: ['human', 'pm', 'chief-of-staff'] } },
};
const businesses = {
demo: {
id: 'demo',
human: 'jason',
arbiters: { technical: 'pm', delivery: 'chief' },
roles,
definitions,
projects: { stack: { root: '/nonexistent' } },
},
};
const ROUTE = 'decision-route-refused';
function setup(t) {
const root = mkdtempSync(join(tmpdir(), 'bus-decision-route-'));
const store = new Store(root);
t.after(() => {
store.close();
rmSync(root, { recursive: true, force: true });
});
const b = new Broker({ store, businesses });
const caps = {};
caps.human = b.bindHuman({ business: 'demo', human: 'jason', via: 'cli', outsideAgent: true });
// Row 121 (#1615): the assistant runs for one thread.
const project = b.request(caps.human, { verb: 'project.create', args: { name: 'demo' } }).id;
const thread = b.request(caps.human, { verb: 'thread.create', args: { project, name: 'main' } }).id;
for (const role of Object.keys(roles)) {
caps[role] = b.bindLaunch({ business: 'demo', role, run: `${role}-run`, harness: 'pi', ...(role === 'assistant' ? { thread } : {}) });
b.request(caps[role], { verb: 'role.claim' });
}
const call = (who, verb, args = {}) => b.request(caps[who], { verb, args });
const raise = (who, action, extra = {}) =>
call(who, 'decision.raise', { action, question: `${action}?`, options, recommendation: 'no', blocking: false, ...extra });
const count = (sql) => store.get(sql).n;
const stored = () => ({
decisions: count('SELECT count(*) n FROM decisions'),
decisionEvents: count('SELECT count(*) n FROM decision_events'),
messages: count('SELECT count(*) n FROM messages'),
allowed: count("SELECT count(*) n FROM events WHERE kind='action.allowed'"),
});
const refusals = () =>
store
.all("SELECT actor_role, body FROM events WHERE kind='action.refused' ORDER BY seq")
.map((e) => [e.actor_role, JSON.parse(e.body).code]);
return { store, call, raise, stored, refusals };
}
test('a cross-role raise whose arbiter the raiser does not hear from is refused and stores nothing', (t) => {
const { raise, stored, refusals } = setup(t);
const before = stored();
// Delivery goes to chief (chief-of-staff), which the coder's receiveFrom doesn't list.
assert.throws(() => raise('coder', 'git.push.working', { domain: 'delivery' }), { code: ROUTE });
assert.throws(() => raise('warden', 'git.push.working', { domain: 'technical' }), { code: ROUTE });
assert.deepEqual(refusals(), [['coder', ROUTE], ['warden', ROUTE]]);
assert.deepEqual(stored(), before, 'no decision, decision event, message or allowed event');
});
test('a gated raise by a role that does not hear from the human is refused and stores nothing', (t) => {
const { raise, stored, refusals } = setup(t);
const before = stored();
// deploy is gated, so the route is the human; warden's receiveFrom lacks human.
assert.throws(() => raise('warden', 'deploy', { target: 'release-1' }), { code: ROUTE });
// A cross-role action outside the raiser's crossRole is gated too.
assert.throws(() => raise('warden', 'task.create'), { code: ROUTE });
assert.deepEqual(refusals(), [['warden', ROUTE], ['warden', ROUTE]]);
assert.deepEqual(stored(), before);
});
test('a route the raiser hears from is allowed, checked from the route to the raiser', (t) => {
const { raise, call, store } = setup(t);
const technical = raise('coder', 'git.push.working', { domain: 'technical' });
const gated = raise('coder', 'deploy', { target: 'release-1' });
assert.deepEqual([technical.route_to, gated.route_to], ['pm', 'human']);
// scribe sends only to pm, but every route here may message scribe.
const routes = [
raise('scribe', 'git.push.working', { domain: 'delivery' }),
raise('scribe', 'git.push.working', { domain: 'technical' }),
raise('scribe', 'deploy', { target: 'release-1' }),
].map((d) => d.route_to);
assert.deepEqual(routes, ['chief', 'pm', 'human']);
// The close message the check stands for reaches the raiser.
call('pm', 'decision.resolve', { id: technical.id, choice: 'yes' });
const close = store.get("SELECT from_role, to_role FROM messages WHERE class='DECISION' AND decision=?", technical.id);
assert.deepEqual({ ...close }, { from_role: 'pm', to_role: 'coder' });
});
test('a refused supersede withdraws nothing', (t) => {
const { raise, store } = setup(t);
const old = raise('coder', 'git.push.working', { domain: 'technical' });
assert.throws(
() => raise('coder', 'git.push.working', { domain: 'delivery', supersedes: old.id }),
{ code: ROUTE },
);
assert.equal(store.get('SELECT count(*) n FROM decision_events WHERE decision=?', old.id).n, 0);
assert.equal(store.get('SELECT count(*) n FROM decisions').n, 1);
});
test("the assistant's within-role and gated raises still work", (t) => {
const { raise, call, store, refusals } = setup(t);
// message.send is within role: routed to the assistant itself, which its own lists don't name.
const within = raise('assistant', 'message.send', { choice: 'yes' });
assert.equal(within.route_to, 'assistant');
assert.equal(
store.get("SELECT op FROM decision_events WHERE decision=?", within.id).op,
'resolved',
);
// Anything else is gated: routed to the human, whom the assistant hears from.
const gated = raise('assistant', 'task.create');
assert.equal(gated.route_to, 'human');
call('human', 'decision.resolve', { id: gated.id, choice: 'no' });
const close = store.get("SELECT from_role, to_role FROM messages WHERE class='DECISION' AND decision=?", gated.id);
assert.deepEqual({ ...close }, { from_role: 'human', to_role: 'assistant' });
assert.deepEqual(refusals(), []);
});