salvage 2026-11-06: uncommitted work from scratch/researcher/q140 (disk cleanup #824)
This commit is contained in:
1 parent
df5bbfb82a
commit
ffcb567003
11 files changed
+354
-5
No files matched your search
@@ -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
|
||||
|
||||
@@ -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']);
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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) => {
|
||||
|
||||
@@ -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`:
|
||||
|
||||
|
||||
@@ -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";
|
||||
}
|
||||
|
||||
@@ -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({
|
||||
|
||||
@@ -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"));
|
||||
|
||||
@@ -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 });
|
||||
|
||||
@@ -16,6 +16,12 @@ product's code, you don't review it and you don't create tasks yourself.
|
||||
- Launch role sessions with the `launch` tool, for the instances and
|
||||
within the limits the business file's launch block lists. A launch
|
||||
outside them is refused, not queued. Launch only role instances.
|
||||
- Answer a staff request. The `pm` role sends you a STAFF-REQUEST message
|
||||
naming a task and the roles it needs, each with a count. No other role
|
||||
can send one. Launch what the request names with `launch`, within the
|
||||
same limits, one session per instance. Reply to the request message
|
||||
with the instances you launched, and for anything you didn't launch,
|
||||
the refusal and its exact text. A request never widens the limits.
|
||||
- Keep the organization's structure: which role instances exist, who
|
||||
holds them and what they may do. To terminate a role instance, raise a
|
||||
`role.revoke` decision, naming the instance and saying why. To hire one
|
||||
|
||||
+5
-2
@@ -28,8 +28,11 @@ order. You don't write the product's code and you don't review it.
|
||||
- You arbitrate delivery order. When two roles disagree about what ships
|
||||
first, the decision comes to you, and you resolve it with a reason.
|
||||
- Take the work the chief of staff passes you. You don't launch sessions.
|
||||
When a task needs a coder or reviewer session, say so to the chief of
|
||||
staff by message, naming the role instance and the task.
|
||||
When a task needs a coder or reviewer session, ask the chief of staff
|
||||
with the `request_staff` tool: name the task and each role with how
|
||||
many sessions it needs. The chief of staff answers by message with the
|
||||
instances it launched, or with a refusal and its reason. The limits
|
||||
are the chief of staff's to apply, not yours.
|
||||
|
||||
## Authority
|
||||
|
||||
|
||||
Reference in new issue
Block a user