diff --git a/packages/bus/README.md b/packages/bus/README.md index 26220494f..7ca9c03f8 100644 --- a/packages/bus/README.md +++ b/packages/bus/README.md @@ -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 diff --git a/packages/bus/src/broker.mjs b/packages/bus/src/broker.mjs index 49c51cd8e..5d0a7118c 100644 --- a/packages/bus/src/broker.mjs +++ b/packages/bus/src/broker.mjs @@ -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']); diff --git a/packages/bus/tests/staff-request.test.mjs b/packages/bus/tests/staff-request.test.mjs new file mode 100644 index 000000000..045aeb985 --- /dev/null +++ b/packages/bus/tests/staff-request.test.mjs @@ -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); +}); diff --git a/packages/cli/tests/launcher.test.mjs b/packages/cli/tests/launcher.test.mjs index 0cfe3cebd..81628fd3a 100644 --- a/packages/cli/tests/launcher.test.mjs +++ b/packages/cli/tests/launcher.test.mjs @@ -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) => { diff --git a/packages/harness/README.md b/packages/harness/README.md index f675eb020..1627f9770 100644 --- a/packages/harness/README.md +++ b/packages/harness/README.md @@ -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`: diff --git a/packages/harness/src/bundle.mjs b/packages/harness/src/bundle.mjs index 3dfa70389..14c28beb6 100644 --- a/packages/harness/src/bundle.mjs +++ b/packages/harness/src/bundle.mjs @@ -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"; } diff --git a/packages/harness/src/tools.mjs b/packages/harness/src/tools.mjs index 7badb1613..e3da1ff94 100644 --- a/packages/harness/src/tools.mjs +++ b/packages/harness/src/tools.mjs @@ -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({ diff --git a/packages/harness/tests/bundle.test.mjs b/packages/harness/tests/bundle.test.mjs index 64e50ae5d..cd4d4b8c6 100644 --- a/packages/harness/tests/bundle.test.mjs +++ b/packages/harness/tests/bundle.test.mjs @@ -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")); diff --git a/packages/harness/tests/tools.test.mjs b/packages/harness/tests/tools.test.mjs index 51b5d7f8e..7217daf77 100644 --- a/packages/harness/tests/tools.test.mjs +++ b/packages/harness/tests/tools.test.mjs @@ -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 }); diff --git a/roles/chief-of-staff.md b/roles/chief-of-staff.md index 28ef82826..dd0245931 100644 --- a/roles/chief-of-staff.md +++ b/roles/chief-of-staff.md @@ -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 diff --git a/roles/pm.md b/roles/pm.md index 0e5409b27..6baa8b6f6 100644 --- a/roles/pm.md +++ b/roles/pm.md @@ -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