salvage 2026-11-06: uncommitted work from scratch/researcher/q140 (disk cleanup #824)

This commit is contained in:
mos committed 2026-11-06 10:05:25 -06:00
1 parent df5bbfb82a
commit ffcb567003
11 files changed
+354 -5

No files matched your search

+3 -1
View File
@@ -147,6 +147,7 @@ an operator inspect content and delivery evidence after an uncertain result.
| `message.send` | `{to,body,class?,in_reply_to?,corrects?,decision?}`; returns `{id,request}`. Human instruction's `request` is its `human.input` event ID. |
| `message.receive` | No args; up to 100 undelivered messages for current holder, including originating `request` for human instructions. A human decision close's message carries the close's `human.input` answer event as its `request`; a role close's has `null`. |
| `message.read` | `{id}`; recipient holder's acknowledgement; no new holder can acknowledge old holder's delivery. |
| `staff.request` | `{task_ref,roles,note?,decision?}`; action `message.send` (row 140, #1634, REQ-COS-1). `roles` is 1 to 10 distinct `{role,count}` entries, `count` an integer 1 to 20; any other shape is `invalid-request`. Only an instance of the `pm` definition sends it (`staff-request-refused`), and it goes to the business's launcher, which must be an instance of `chief-of-staff` (`no-chief-of-staff`); the definitions' `messaging` lists apply as for `message.send`. Sends that instance a STAFF-REQUEST message naming the task and the roles with counts, and writes an `action.allowed` event with `operation: staff.request`, `staff_for` and `roles`. `message.send` and `thread.send` refuse the class `invalid-class`, so no other path writes one. It grants nothing: the chief of staff launches through `role.launch` within the organization's limits and replies to the message with the instances it launched or the refusal. Returns `{message,to}`. |
| `review.request` | `{task_ref,commit,to,note?,decision?}`; action `review.request` (row 93, #1587). `commit` must be the task's latest pushed commit: an older one refuses `stale-commit`, any other `unknown-commit`. `to` must be another role holding `review.verdict` (`unknown-role`, `self-review`, `not-a-reviewer`). Writes a `review.requested` event `{task_ref,project,ref,commit,to,message,held}` and sends `to` a REVIEW-REQUEST message naming it. `held` is the run id holding the `to` role when the request is routed (row 105, #1599), or `null` when no run holds it: the message then waits for a claim, and the requester should tell whoever launches roles. Returns `{request,message,commit,ref,held}`. |
| `review.verdict` | `{task_ref,request,verdict,body,decision?}`; action `review.verdict`. `verdict` is `approve` or `changes`. `request` must be a `review.requested` event on the task addressed to the caller's role (`request-not-found`), with no verdict yet (`verdict-exists`). Writes a `review.verdict` event `{task_ref,request,commit,verdict,message}` and sends the requesting role a REVIEW-RESULT in reply to the request's message. Returns `{verdict,message,commit}`. |
| `event.emit` | `{kind:'action.allowed',body:{action:'routine',target?},subject?}`; routine observations only. |
@@ -268,7 +269,8 @@ message stranded for a role nobody holds shows once a run claims the role.
Unknown keys, roles, references, actions and verbs refuse. If writing refusal
evidence fails, the caller receives the static `storage-unavailable` code. `human` is the reserved
recipient. Message classes are REQUEST, ASSIGNMENT, REVIEW-REQUEST, REVIEW-RESULT,
RESULT, INFO, DECISION and REACTION. References cannot cross businesses.
RESULT, INFO, DECISION and REACTION. `staff.request` also writes STAFF-REQUEST (row 140);
`message.send` and `thread.send` refuse that class. References cannot cross businesses.
Routing is immutable at raise: within-role closes atomically with `choice`,
cross-role routes to the configured delivery arbiter (or technical arbiter with
+47
View File
@@ -100,6 +100,14 @@ export const ORGANIZATION_KEYS = ['revision', 'limits', 'models', 'instances'];
// Row 123 (#1617): role.end never reaches the assistant (the user's seat) or the caller's own run.
const END_PROTECTED = ['assistant'];
const VERDICTS = ['approve', 'changes'];
// Row 140 (#1634, REQ-COS-1): a STAFF-REQUEST goes from an instance of STAFF_FROM to the business's
// launcher, which must be an instance of STAFF_TO. Only staff.request writes the class. STAFF_ROLES
// and STAFF_COUNT bound the request's shape; they are not capacity limits, which the organization
// file holds and the host's launch enforces.
const STAFF_FROM = 'pm';
const STAFF_TO = 'chief-of-staff';
const STAFF_ROLES = 10;
const STAFF_COUNT = 20;
// Row 93 (#1587): the review loop's evidence, written only by the verbs below. A push is an
// action.allowed for git.push.working that names its commit, written only by recordPush.
const REVIEW_KINDS = ['review.requested', 'review.verdict'];
@@ -1286,6 +1294,45 @@ export class Broker {
this.#delivery(m.id, 'read', s.human || s.tester ? null : this.#own(s));
return { read: true };
}
// Row 140 (#1634, REQ-COS-1): the pm asks the chief of staff for role sessions for a task,
// naming role definitions and counts. It spends the caller's message.send grant and grants
// nothing: the chief of staff decides, launches through role.launch within the organization's
// limits, and answers by message. message.send refuses the STAFF-REQUEST class, so this verb
// is the only way to write one.
case 'staff.request': {
keys(a, ['task_ref', 'roles', 'note', 'decision'], ['task_ref', 'roles']);
if (!taskRef(a.task_ref) || !Array.isArray(a.roles) || a.roles.length < 1 || a.roles.length > STAFF_ROLES)
fail('invalid-request');
for (const r of a.roles) {
keys(r, ['role', 'count'], ['role', 'count']);
identifier(r.role);
if (!Number.isInteger(r.count) || r.count < 1 || r.count > STAFF_COUNT) fail('invalid-request');
}
if (new Set(a.roles.map((r) => r.role)).size !== a.roles.length) fail('invalid-request');
if (a.note !== undefined) string(a.note, 16384);
const chief = b.launch?.by;
const withinRole = this.#classification(s, 'message.send') === 'within-role';
this.#consumeAuthority(
s,
'message.send',
{ decision: withinRole ? null : (a.decision ?? null), target: chief ?? null },
// Not task_ref: an action event with that key must be filed under the task, and this one is
// filed under the chief of staff it was sent to.
{ operation: 'staff.request', staff_for: a.task_ref, roles: a.roles },
);
if (b.roles[s.role]?.definition !== STAFF_FROM) fail('staff-request-refused');
if (!chief || b.roles[chief]?.definition !== STAFF_TO) fail('no-chief-of-staff');
this.#checkMessaging(s.business, this.#sender(s), chief);
const mid = randomUUID();
const list = a.roles.map((r) => `${r.role} x${r.count}`).join(', ');
this.#reviewMessage(s, mid, {
to: chief,
cls: 'STAFF-REQUEST',
decision: withinRole ? null : (a.decision ?? null),
body: `Staff request for ${a.task_ref}: ${list}. Launch what the organization's limits allow with launch, then answer this message with the instances you launched, or with the refusal and its reason.${a.note ? '\n\n' + a.note : ''}`,
});
return { message: mid, to: chief };
}
// Row 93 (#1587): the coder asks a reviewer role to review the task's latest pushed commit.
case 'review.request': {
keys(a, ['task_ref', 'commit', 'to', 'note', 'decision'], ['task_ref', 'commit', 'to']);
+198
View File
@@ -0,0 +1,198 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync, mkdtempSync, 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';
// Row 140 (#1634, REQ-COS-1): the pm asks the chief of staff for role sessions with staff.request, and
// the chief of staff answers by message. The grant is message.send, which the pm already holds, so
// the request widens nothing; the roles' authority is read from the shipped files.
const shipped = (name) =>
JSON.parse(readFileSync(fileURLToPath(new URL(`../../../roles/${name}.json`, import.meta.url)), 'utf8'));
const authority = { pm: shipped('pm').authority, chief: shipped('chief-of-staff').authority };
const none = { authority: { withinRole: ['message.send'], crossRole: [] } };
const TASK = 'vikunja:1/2';
const WANT = { task_ref: TASK, roles: [{ role: 'coder', count: 2 }, { role: 'reviewer', count: 1 }] };
function setup(t, { launch, definitions = {}, roles } = {}) {
const root = mkdtempSync(join(tmpdir(), 'bus-staff-'));
const store = new Store(root);
t.after(() => {
store.close();
rmSync(root, { recursive: true, force: true });
});
const set = roles ?? {
chief: { definition: 'chief-of-staff', authority: authority.chief },
pm: { definition: 'pm', authority: authority.pm },
coder: { definition: 'coder', ...none },
assistant: { definition: 'assistant', ...none },
};
const b = new Broker({
store,
businesses: {
demo: {
id: 'demo',
human: 'jason',
arbiters: { technical: 'pm', delivery: 'chief' },
launch: launch === undefined ? { by: 'chief', instances: ['coder'], max: { opus: 2, sonnet: 2 } } : launch,
roles: set,
definitions,
vars: { 'bus.tester': true },
},
},
});
const caps = {
human: b.bindHuman({ business: 'demo', human: 'jason', via: 'cli', outsideAgent: true }),
reader: b.bindReader({ business: 'demo' }),
tester: b.bindTester({ business: 'demo' }),
};
// The assistant runs for one thread (row 121), so it is never launched here; thread.send needs only the thread.
let thread;
if (set.assistant) {
const project = b.request(caps.human, { verb: 'project.create', args: { name: 'demo' } }).id;
thread = b.request(caps.human, { verb: 'thread.create', args: { project, name: 'main' } }).id;
}
for (const role of Object.keys(set).filter((r) => r !== 'assistant')) {
caps[role] = b.bindLaunch({ business: 'demo', role, run: `${role}-run`, harness: 'pi' });
b.request(caps[role], { verb: 'role.claim' });
}
const call = (who, verb, args = {}) => b.request(caps[who], { verb, args });
const allowed = () =>
store
.all("SELECT actor_role, subject, body FROM events WHERE kind='action.allowed' ORDER BY seq")
.map((e) => ({ ...e, body: JSON.parse(e.body) }));
const staffMessages = () => store.all("SELECT * FROM messages WHERE class='STAFF-REQUEST'");
return { b, store, caps, call, allowed, staffMessages, thread };
}
test('REQ-COS-1: the pm asks the chief of staff for roles and counts; the chief receives a STAFF-REQUEST and answers it', (t) => {
const { call, allowed } = setup(t);
const sent = call('pm', 'staff.request', { ...WANT, note: 'the build needs two coders' });
assert.deepEqual(sent, { message: sent.message, to: 'chief' });
const [m, ...rest] = call('chief', 'message.receive');
assert.equal(rest.length, 0);
assert.equal(m.id, sent.message);
assert.equal(m.class, 'STAFF-REQUEST');
assert.equal(m.from_role, 'pm');
assert.equal(m.to_role, 'chief');
assert.match(m.body, /^Staff request for vikunja:1\/2: coder x2, reviewer x1\. /);
assert.match(m.body, /\n\nthe build needs two coders$/);
// The chief of staff answers in reply, with the instances it launched or a refusal and its reason.
const answer = call('chief', 'message.send', { to: 'pm', body: 'launched coder; reviewer refused: capacity-full', class: 'RESULT', in_reply_to: m.id });
const [back] = call('pm', 'message.receive');
assert.equal(back.id, answer.id);
assert.equal(back.in_reply_to, m.id);
// It spends the pm's message.send, within the role, and the log names the request.
const [event, ...more] = allowed().filter((e) => e.body.operation === 'staff.request');
assert.equal(more.length, 0);
assert.equal(event.actor_role, 'pm');
assert.equal(event.body.action, 'message.send');
assert.equal(event.body.class, 'within-role');
assert.equal(event.body.target, 'chief');
assert.equal(event.body.staff_for, TASK);
assert.deepEqual(event.body.roles, WANT.roles);
});
test('REQ-COS-1: only the pm can send a staff request; every other session is refused and the chief of staff hears nothing', (t) => {
const { call, staffMessages, thread } = setup(t);
for (const who of ['coder', 'chief']) {
assert.throws(() => call(who, 'staff.request', WANT), /staff-request-refused/, who);
// message.send can't write the class either, from any role.
assert.throws(() => call(who, 'message.send', { to: 'chief', body: 'x', class: 'STAFF-REQUEST' }), /invalid-class/, who);
}
assert.throws(() => call('pm', 'message.send', { to: 'chief', body: 'x', class: 'STAFF-REQUEST' }), /invalid-class/);
assert.throws(() => call('human', 'staff.request', WANT), /agent-required/);
assert.throws(() => call('human', 'message.send', { to: 'chief', body: 'x', class: 'STAFF-REQUEST' }), /invalid-class/);
assert.throws(() => call('human', 'thread.send', { thread, body: 'x', class: 'STAFF-REQUEST' }), /invalid-class/);
assert.throws(() => call('reader', 'staff.request', WANT), /read-only/);
assert.throws(() => call('tester', 'staff.request', WANT), /tester-refused/);
assert.deepEqual(call('chief', 'message.receive'), []);
assert.deepEqual(staffMessages(), []);
});
test('REQ-COS-1: a pm without message.send is refused like any other gated action', (t) => {
const { call, staffMessages } = setup(t, {
roles: {
chief: { definition: 'chief-of-staff', authority: authority.chief },
pm: { definition: 'pm', authority: { withinRole: ['task.assign'], crossRole: [] } },
},
});
assert.throws(() => call('pm', 'staff.request', WANT), /decision-required/);
assert.deepEqual(staffMessages(), []);
});
test('REQ-COS-1: the request goes to the business launcher, and only when that is a chief of staff', (t) => {
for (const launch of [null, { by: 'coder', instances: ['pm'], max: { opus: 1, sonnet: 1 } }]) {
const { call, staffMessages } = setup(t, { launch });
assert.throws(() => call('pm', 'staff.request', WANT), /no-chief-of-staff/, JSON.stringify(launch));
assert.deepEqual(staffMessages(), []);
}
});
test('REQ-ASSIST-2: the role definitions\' messaging lists hold for a staff request, sender and recipient', (t) => {
const out = setup(t, { definitions: { pm: { messaging: { sendTo: ['assistant'], receiveFrom: ['chief-of-staff'] } } } });
assert.throws(() => out.call('pm', 'staff.request', WANT), /message-recipient-refused/);
const into = setup(t, { definitions: { 'chief-of-staff': { messaging: { sendTo: ['pm'], receiveFrom: ['assistant'] } } } });
assert.throws(() => into.call('pm', 'staff.request', WANT), /message-sender-refused/);
const open = setup(t, { definitions: { 'chief-of-staff': { messaging: { sendTo: ['pm'], receiveFrom: ['pm'] } } } });
assert.equal(open.call('pm', 'staff.request', WANT).to, 'chief');
for (const s of [out, into]) assert.deepEqual(s.staffMessages(), []);
});
test('a staff request names a task, 1 to 10 distinct roles and counts of 1 to 20; nothing else is accepted', (t) => {
const { call, staffMessages } = setup(t);
const roles = (n) => Array.from({ length: n }, (_, i) => ({ role: `role-${i}`, count: 1 }));
const bad = [
{},
{ roles: WANT.roles },
{ task_ref: TASK },
{ ...WANT, task_ref: 'vikunja:0/2' },
{ ...WANT, task_ref: 'T-1' },
{ ...WANT, roles: [] },
{ ...WANT, roles: 'coder' },
{ ...WANT, roles: roles(11) },
{ ...WANT, roles: [{ role: 'coder', count: 0 }] },
{ ...WANT, roles: [{ role: 'coder', count: 21 }] },
{ ...WANT, roles: [{ role: 'coder', count: 1.5 }] },
{ ...WANT, roles: [{ role: 'coder', count: '2' }] },
{ ...WANT, roles: [{ role: 'coder' }] },
{ ...WANT, roles: [{ count: 1 }] },
{ ...WANT, roles: [{ role: 'coder', count: 1, model: 'opus' }] },
{ ...WANT, roles: [{ role: 'bad role', count: 1 }] },
{ ...WANT, roles: [{ role: 'coder', count: 1 }, { role: 'coder', count: 2 }] },
{ ...WANT, note: '' },
{ ...WANT, to: 'coder' },
];
for (const args of bad) assert.throws(() => call('pm', 'staff.request', args), /invalid-request/, JSON.stringify(args));
assert.deepEqual(staffMessages(), []);
for (const ok of [roles(10), [{ role: 'coder', count: 20 }], [{ role: 'coder', count: 1 }]])
assert.equal(call('pm', 'staff.request', { task_ref: TASK, roles: ok }).to, 'chief');
assert.equal(staffMessages().length, 3);
});
test('REQ-COS-1: a staff request grants nothing: the pm still can\'t launch and the chief of staff launches as before', (t) => {
// The shipped files: the pm holds no role.launch, the chief of staff holds it within its role.
assert.ok(!authority.pm.withinRole.includes('role.launch') && !authority.pm.crossRole.includes('role.launch'));
assert.ok(authority.chief.withinRole.includes('role.launch'));
const { b, caps, call } = setup(t);
const launches = () => ({
pm: (() => {
try {
return b.authorize(caps.pm, 'role.launch', { target: 'coder' }).class;
} catch (e) {
return e.code ?? e.message;
}
})(),
chief: b.authorize(caps.chief, 'role.launch', { target: 'coder' }).class,
});
const before = launches();
assert.match(before.pm, /decision-required/);
assert.equal(before.chief, 'within-role');
call('pm', 'staff.request', WANT);
call('chief', 'message.receive');
assert.deepEqual(launches(), before);
});
+34
View File
@@ -291,6 +291,40 @@ test("the chief of staff launches a coder through its launch tool; the coder ans
assert.ok(readSessions(f.dataRoot).some((s) => s.run === chief.run));
});
// Row 140 (#1634, REQ-COS-1): the pm asks the chief of staff for staff through request_staff, over the real
// tool socket; the request grants no launch, and the chief's launches stay inside the organization's limits.
test("a launched pm's request_staff reaches the chief of staff; no other session has the tool and the launch limits still hold", { skip, timeout: 60000 }, async (t) => {
const { f, launcher, client, cto } = await setup(t, (doc) => {
doc.roles.pm.vars = { harness: "pi", model: "claude-sonnet-5-5" };
doc.launch.instances.push("pm");
doc.launch.limits.models.zai["claude-sonnet-5-5"] = 2;
return doc;
});
const sock = launchSocketPath(f.dataRoot);
await launcher.launchPm();
const call = async (to, body) => {
const sent = await client.call("message.send", { to, class: "REQUEST", body });
return until(async () => (await client.call("message.receive")).find((m) => m.in_reply_to === sent.id));
};
// The chief launches the pm within its limits, and the pm holds request_staff.
assert.equal(JSON.parse((await call("chief", 'TOOL launch {"instance":"pm"}')).body).instance, "pm");
const ask1 = await call("pm", `TOOL request_staff ${JSON.stringify({ task_ref: "vikunja:1/2", roles: [{ role: "coder", count: 1 }, { role: "reviewer", count: 1 }], note: "build and review" })}`);
assert.equal(ask1.from_role, "pm");
assert.equal(JSON.parse(ask1.body).to, "chief");
// A refusal from the broker comes back as the tool's error, the same path any typed tool takes.
const bad = await call("pm", `TOOL request_staff ${JSON.stringify({ task_ref: "vikunja:1/2", roles: [{ role: "coder", count: 0 }] })}`);
assert.match(bad.body, /invalid-request/);
// The chief of staff has no request_staff, and a pm has no launch.
assert.equal((await call("chief", 'TOOL request_staff {"task_ref":"vikunja:1/2","roles":[{"role":"coder","count":1}]}')).body, "refused: unknown-tool");
assert.equal((await call("pm", 'TOOL launch {"instance":"coder"}')).body, "refused: unknown-tool");
// Nothing was launched by asking: the chief of staff's limits are the same, and sonnet has one place left.
assert.deepEqual(readSessions(f.dataRoot).map((s) => s.instance).sort(), ["chief", "pm"]);
const launched = await call("chief", 'TOOL launch {"instance":"coder"}');
assert.equal(JSON.parse(launched.body).instance, "coder");
assert.deepEqual(await ask(sock, `${JSON.stringify({ cap: cto.cap, instance: "reviewer" })}\n`), { ok: false, error: "capacity-full" });
assert.equal(log(f).filter((e) => e.event === "launch" && e.launchedBy === "pm").length, 0);
});
// Row 91 (#1585): the project clone in each workspace.
// Row 117 (#1611): and a dirty one is fetched, not merged, and logged.
test("each launch makes sure the workspace has a clone of the project: cloned, fast-forwarded, or fetched and logged", { skip, timeout: 60000 }, async (t) => {
+6
View File
@@ -88,6 +88,12 @@ file outside the workspace, which the gate refuses to read (row 89, #1583;
tasks, 50 at a time, without descriptions. `get_task` takes a `task_ref`
and returns that task in full. `packages/bus/README.md` has the reply.
`request_staff` (row 140, #1634) is the `pm` definition's tool for asking the
chief of staff for role sessions. It spends `message.send` through the
`staff.request` verb and takes `task_ref`, `roles` (1 to 10 entries of `role`
and `count`, 1 to 20) and an optional `note`. A pm has no `launch` tool, and
the chief of staff's `launch` offer is still its launch block's instances.
The chief of staff's two grants from row 123 have tools (row 132, #1628),
so its manifest lists both in `typed` and nothing in `untyped`:
+3
View File
@@ -99,6 +99,9 @@ function prompt({ contract, resolved, session, tools, untyped }) {
lines.push("- Review loop: commit on a branch of your clone, push_working it, then request_review with the commit it returned. Work that isn't pushed can't be reviewed, and a task with pushed work closes only on an approve verdict for its latest push. After a changes verdict, commit the fixes, push again and ask again.");
if (named.has("fetch_review"))
lines.push("- Reviews: a REVIEW-REQUEST names a request id. fetch_review it, read the commit in your clone, and answer with review_verdict citing the request. One verdict per request.");
// Row 140 (#1634): the pm asks the chief of staff for sessions; it launches none itself.
if (named.has("request_staff"))
lines.push("- Staff: you don't launch sessions. When a task needs a coder or reviewer session, request_staff names the task and each role with how many. The chief of staff answers by message with the instances it launched, or with the refusal and its reason.");
if (untyped.length) lines.push(`- Actions you hold that have no bus tool yet: ${untyped.join(", ")}. Say so instead of working around it.`);
return lines.join("\n") + "\n";
}
+12
View File
@@ -93,6 +93,18 @@ export function typedTools({ resolved, arbiter = false, tracker = false, project
in_reply_to: str("Id of the message this answers"),
decision: COMMON.decision,
}, ["to", "body"]));
// Row 140 (#1634, REQ-COS-1): the pm asks the chief of staff, the only launcher, for sessions. The broker
// addresses the request to the launcher and refuses any sender that isn't an instance of the pm role.
if (resolved.definition === "pm")
add("request_staff", "staff.request", "message.send", "Ask the chief of staff to launch role sessions for a task: name each role and how many. The chief of staff launches what the organization's limits allow and answers with the instances it launched, or with a refusal and its reason. You don't launch sessions yourself.", obj({
task_ref: TASK_REF,
roles: { type: "array", minItems: 1, maxItems: 10, description: "The roles wanted and how many of each", items: obj({
role: str("Role to staff, such as coder or reviewer"),
count: { type: "integer", minimum: 1, maximum: 20, description: "How many" },
}, ["role", "count"]) },
note: str("What the sessions are for, for the chief of staff"),
decision: COMMON.decision,
}, ["task_ref", "roles"]));
}
if (resolved.launch) {
add("launch", "launch", "role.launch", `Launch a managed session for one of these role instances: ${resolved.launch.instances.join(", ")}. The host refuses an instance that is already running, a full model family, or a launch while launches are switched off.`, obj({
+11 -1
View File
@@ -42,7 +42,7 @@ test("a pi bundle: prompt, policy, tools and manifest, 0600 in a 0700 directory"
const prompt = readFileSync(b.files.prompt, "utf8");
assert.match(prompt, /^# Contract\n\nDo the work\.\n\n## This session\n/);
assert.match(prompt, /Role instance: pm \(definition pm\)\. Run: run-1\./);
assert.match(prompt, /Bus tools: send_message, task_create, /);
assert.match(prompt, /Bus tools: send_message, request_staff, task_create, /);
assert.doesNotMatch(prompt, /Bus tools: [^.]*\blaunch\b/);
// Row 90 (#1584): PM fault 10 (#228 c91).
assert.match(prompt, /^- Only the human stops a run, with `mosaic stop`\. If you think a run should stop, raise a role\.revoke decision with blocking false/m);
@@ -182,6 +182,16 @@ test("the prompt explains the review loop to a role with push_working, and revie
assert.deepEqual(lines(build(t, resolvedFor(t, "coder"))), []);
});
// Row 140 (#1634): the pm's prompt names request_staff; no other role's does.
test("the prompt tells the pm to ask the chief of staff for sessions, and no other role", (t) => {
const staff = (b) => readFileSync(b.files.prompt, "utf8").split("\n").filter((l) => /^- Staff: /.test(l));
const pm = staff(build(t, resolvedFor(t, "pm")));
assert.equal(pm.length, 1);
assert.match(pm[0], /^- Staff: you don't launch sessions\. When a task needs a coder or reviewer session, request_staff names the task/);
for (const instance of ["chief", "coder", "reviewer"])
assert.deepEqual(staff(build(t, resolvedFor(t, instance, (d) => (d.roles[instance].vars = { ...d.roles[instance].vars, harness: "pi" })))), [], instance);
});
test("a bundle is written once: an existing file refuses", (t) => {
const dir = scratch(t);
mkdirSync(join(dir, "bundle"));
+29 -1
View File
@@ -10,7 +10,7 @@ test("the PM gets its task verbs and the reads, and no launch", (t) => {
const pm = resolvedFor(t, "pm");
const tools = typedTools({ resolved: pm, arbiter: true, tracker: true });
assert.deepEqual(names(tools), [
"send_message",
"send_message", "request_staff",
"task_create", "task_assign", "task_reassign", "task_schedule", "task_priority_change", "task_scope_change",
"task_update_assigned", "task_close",
"raise_decision", "resolve_decision", "list_agents", "inbox", "trail", "list_tasks", "get_task", "list_requirements",
@@ -42,6 +42,34 @@ test("the chief of staff gets launch, send_message, end_run and change_organizat
assert.deepEqual(untypedActions(chief, tools), []);
});
// Row 140 (#1634, REQ-COS-1): the pm asks for staff with request_staff, which spends message.send; the
// chief of staff and every other role has no such tool, and the chief's launch offer is unchanged.
test("request_staff is the pm's alone: staff.request over message.send, roles and counts bounded", (t) => {
const tools = typedTools({ resolved: resolvedFor(t, "pm"), tracker: true });
const ask = tools.find((x) => x.name === "request_staff");
assert.deepEqual([ask.verb, ask.action], ["staff.request", "message.send"]);
assert.deepEqual(Object.keys(ask.parameters.properties), ["task_ref", "roles", "note", "decision"]);
assert.deepEqual(ask.parameters.required, ["task_ref", "roles"]);
assert.equal(ask.parameters.additionalProperties, false);
const roles = ask.parameters.properties.roles;
assert.deepEqual([roles.minItems, roles.maxItems], [1, 10]);
assert.deepEqual(roles.items.required, ["role", "count"]);
assert.equal(roles.items.additionalProperties, false);
assert.deepEqual([roles.items.properties.count.type, roles.items.properties.count.minimum, roles.items.properties.count.maximum], ["integer", 1, 20]);
for (const instance of ["chief", "coder", "reviewer"])
assert.ok(!names(typedTools({ resolved: resolvedFor(t, instance), tracker: true })).includes("request_staff"), instance);
const assistant = resolvedFor(t, "assistant", (d) => (d.roles.assistant = { definition: "assistant", holder: "mos" }));
assert.ok(!names(typedTools({ resolved: assistant })).includes("request_staff"));
// A pm without message.send is offered no request_staff, as for send_message.
const mute = resolvedFor(t, "pm", (d) => (d.roles.pm.vars["limits.authority"] = ["task.assign"]));
assert.ok(!names(typedTools({ resolved: mute, tracker: true })).includes("request_staff"));
// The pm still has no launch tool, and the chief of staff's launch offer is its limits, not a request.
assert.ok(!names(tools).includes("launch"));
const chief = resolvedFor(t, "chief");
const launch = typedTools({ resolved: chief, tracker: true }).find((x) => x.name === "launch");
assert.deepEqual(launch.parameters.properties.instance.enum, chief.launch.instances);
});
// Row 132 (#1628, REQ-ROLE-2, REQ-COS-1, REQ-LIMIT-1): each tool maps to the broker verb and action row 123 added.
test("end_run sends role and reason, no decision; change_organization sends revision and the organization keys", (t) => {
const tools = typedTools({ resolved: resolvedFor(t, "chief"), tracker: true });