Compare commits

..
127 Commits
Author SHA1 Message Date
jason.woltje 2db4f24fd8 fix(model-proxy): re-check 3: mosaic org update that takes cliproxy off an organization records the removal in the proxy's receipts first and saves nothing if it cannot; Ride all reads the receipts again before each add, so a removal saved during a run is honoured; the bus-running and unreadable skip lines say what to do (#1873, lane ride-default) 2026-11-19 13:13:05 -06:00
jason.woltje 9bfe101176 fix(model-proxy): round 3: a Console save that takes cliproxy off an organization records the removal in the proxy's receipts first, and Ride all skips as removed any organization with any sign it was or may have been on cliproxy; a receipt line that does not parse fails closed; each add records an intent before it starts and an unknown outcome stays recorded; the fixture move and listing read stopped from the bus status and its process id; receipt and change-log reads check owner, mode and no symlink (#1873, lane ride-default) 2026-11-19 13:13:05 -06:00
jason.woltje 869d259036 fix(model-proxy): review round: an organization the proxy once put cliproxy on and that lacks it now is skipped as removed, read from the proxy's own receipts; an organization riding now is already riding whatever its history; a repeated catalogue key keeps the usable row; the page paints a Ride all answer while a load waits, names org-forbidden in plain words and gives a neutral fallback (#1873, lane ride-default) 2026-11-19 13:13:05 -06:00
jason.woltje 8200ea238c feat(model-proxy): Ride all puts the owner's existing organizations on the instance model proxy, and a cliproxy preset starts a new one on the owner's models (#1873, lane ride-default)
A cliproxy organization preset offers a model from the owner's catalogue and says in plain words
why it can't be used: no proxy, no riding bus answered, or no catalogue model is available. The
organization service passes an optional model to a preset's overlay; other presets ignore it.

Ride all, an instance-owner action on the Model proxy page, adds cliproxy to each organization
through that organization's own plugins.set. It skips and names an organization whose change log
shows cliproxy removed, whose bus is down, or whose bus has no proxy client. Proxy admin status
names it as the next step. A fixture organization is listed as using stand-in models; one more
confirmed click moves a stopped one to the owner's models through the organization service's
existing whole-document update at the revision read.

A fenced proxy then refuses each riding organization's launches with proxy-uncertain, a direct
anthropic route included.
2026-11-19 13:13:05 -06:00
jason.woltje 196505e6ef fix(bus): review round: the restart notice shows only on a ready catalogue, since a fenced, colliding or down proxy still refuses after a restart (#1873, lane pickup-launch)
A bus booted with the proxy on a fenced instance reads the same unavailable catalogue, so the
notice sent the owner to a restart that stops running agents and starts none. The test proves
that and shows the notice again once the fence is gone. The disabled check goes away with it;
the disabled test now says the routes verb answers disabled itself.
2026-11-19 12:08:41 -06:00
jason.woltje f7c0e4f46c fix(bus): a bus that picked up the shared proxy says on its catalogue that a restart is needed to start agents on these models (#1873, lane pickup-launch)
A picked-up client serves accounts and the catalogue, but a launch on it is refused at bus
admission (model-provider-unavailable): the host launcher keeps its boot system with no proxy,
and the bus has no ModelKeys. While the bus holds a late client and the catalogue is not
disabled, the catalogue appends one notice after its own: "Restart this organization to start
agents on these models." A boot proxy, a disabled catalogue, refused settings and a dropped
client carry no such notice. Tests cover the launch refusal, refused settings, a dropped
client and a key scan over the launch path.
2026-11-19 12:08:41 -06:00
jason.woltje 5c975faddd fix(model-proxy): review round: the preflight comment says every v8 proxy applies a key PUT by an async reload; a re-probe waits about the time left, not the client default; the README says the proxy unit reads PIN from the tree it was installed from and names .codex-refresh; two test headers stop naming only 8.0.42 (#1873, lane proxy-pin) 2026-11-19 11:08:23 -06:00
jason.woltje 462215b4bd chore(model-proxy): pin CLIProxyAPI 8.0.79; proxy.json from an earlier PIN stays valid; preflight re-probes a just-issued key's 401 briefly (#1873, lane proxy-pin)
The PIN moves from 8.0.42 to 8.0.79 with the upstream archive checksum and the
extracted binary checksum. The panel stays 1.26.7.

proxy.json keeps the binary path of the PIN it was created under. A path of the
form <dataRoot>/opt/cliproxyapi/<version>/cli-proxy-api now validates and reads
as the current pinned path, so an instance created on 8.0.42 needs no edit. The
runner still runs only the verified pinned install.

8.0.79 applies a key-list PUT by an async reload a few milliseconds after it
answers, so a just-issued key answers 401 at first. Preflight now probes again
on 401 only, for at most ISSUE_PROBE_TIMEOUT_MS (2 s). Any other non-2xx still
refuses on the first answer.
2026-11-19 11:08:23 -06:00
jason.woltje d0293d6602 fix(bus): review round: proxy init creates the lock before it installs the client, so a lock that refuses leaves no client; a default-instance bus test proves the catalogue refreshes at once on pickup and on drop (#1873, lane proxy-pickup) 2026-11-19 09:51:39 -06:00
jason.woltje 912138ff61 feat(bus): a running organization bus picks up the shared proxy without a restart (#1873, lane proxy-pickup)
A bus started before the instance had a proxy checks once at the next accounts, page, catalogue
or fence request, and loads the client through the start path's checks, loader and lock. A client
got that way, or by the bus's own init, is checked again at each such request and dropped when
proxy.json goes away, no longer loads, moves port, the key stops loading, the lock refuses, or a
dev fixture the host would refuse is in use. While there is no client, the bus names the cause in
one plain line on not-configured and on the unavailable catalogue, and the Console shows it.
2026-11-19 09:39:41 -06:00
jason.woltje 4a8d310cd5 docs(webui): the Triage settings comment says the host reads the stored route at its next admit, now that the host has a route (#1873, lane triage-wiring) 2026-11-18 16:01:19 -06:00
jason.woltje c28ca57af6 fix(triage): review round: the host writes claude-code's bundle and sets its MOSAIC_ names, so a real harness answers; pi is refused as incompatible; proxy.json is read at each admit; a persistent marker makes the start after an unknown end fresh across a restart; the session key and key-shaped strings are removed from Triage lines (#1873, lane triage-wiring) 2026-11-18 16:01:12 -06:00
jason.woltje 255c1575bb feat(triage): the Console resolves Triage's model route at each admit
The Triage host got route: null. It now gets a route read fresh at each
admit from the route store, the key file, each active organization's
model catalogue (held to checkRoutes) and the harness module. The spawn
env adds only ANTHROPIC_BASE_URL (the instance proxy) and
ANTHROPIC_AUTH_TOKEN (the Triage key); the host sets every MOSAIC_ name.

The key file reader moves to packages/cli/src/triage-key-file.mjs so the
Console reads the key with the key verbs' checks without loading the
proxy management client; triage-key.mjs re-exports it. Each refusal (no
route, no key, unsafe key, proxy down, model not offered, no catalogue,
harness incompatible) launches nothing and answers 409 with one plain
line. Every admit runs the host's fences on the answer, a session
running or not.

The cap fails closed: two turns in a row with unknown usage end the
session with a host line; the next message starts a new run with a
fresh session directory, and its usage counts again.

#1873, lane triage-wiring
2026-11-18 16:01:12 -06:00
jason.woltje 0ba50111f6 test(webui): the Triage drawer's no-Triage-request checks skip the static triage-settings.js script every page loads; it carries no data, and the Settings panel's own test shows a non-owner reads no route (#1873, lane triage-settings) 2026-11-18 15:06:03 -06:00
jason.woltje dab07f0ff5 fix(webui): Triage route review round: a save sends the revision its fields were read at, so a route saved elsewhere answers as stale instead of being written over, and an untouched page follows the store; a read follows the repo GET convention, so a LAN dev host with no Fetch Metadata reads the route while a write still needs one matching Origin and same-origin; a zone in another case is stored in its canonical spelling; focus lands on the saved line; the organization catalogues are read in parallel (#1873, lane triage-settings) 2026-11-18 14:40:22 -06:00
jason.woltje 561ff77e48 feat(webui): Settings > Triage reads and saves the Triage route (#1873, lane triage-settings)
GET and POST /api/triage/route, owner only behind the proxy-admin gate, with one
Origin and Sec-Fetch-Site same-origin on a write and Fetch Metadata on a read.
GET returns the stored route or says it is not set, plus the merged catalogue
choices (model keys, availability, compatible installed harnesses) with no
provider, upstream, module, key or path. POST takes model, harness, cap, time
zone and revision, checks the route with checkRoutes against the merged
catalogue (offered, available, compatible, installed), requires a known time
zone with no default, and writes through the store's writeRoute, so the lock,
the revision compare and the receipt are the store's. A stale revision answers
409 with the stored revision. updatedBy is the signed-in owner.

The Settings > Triage page shows only to the owner /api/config marks proxyAdmin.
Model and harness selects (the harness list is the chosen model's), a cap in
tokens, reset 00:00 read only, a time zone, Save. Not set before a first save;
a refusal is one line and keeps the fields; a stale save offers Reload route; a
second Save while one runs does nothing; one line says saving does not start
Triage. cli.mjs keeps route: null for the Triage host.
2026-11-18 14:40:21 -06:00
jason.woltje e1642be760 test(webui): drawer Stop review round: two Stops run at once in two drawers; coder's Stop the bus takes ends and repaints the page while ideas' still runs, and ideas keeps its running state; then ideas' is refused and each drawer keeps its own line (#1873, lane sp20-drawer-stop) 2026-11-18 14:33:52 -06:00
jason.woltje b23ccdfc12 fix(webui): Stop in the agent drawer: an archived or unavailable organization says so in Restart's plain line ending Nothing changed, not Outcome unknown, with one test each; each Stop keeps its own state per agent, as each restart does, so a second Stop or question in another drawer no longer drops a running Stop's line or its running state, with a two-drawer test (#1873, lane sp20-drawer-stop) 2026-11-18 14:33:52 -06:00
jason.woltje 57af33630d test(triage): a repeated usage.begin keeps the first baseline (review round, #1873, lane triage-cap) 2026-11-18 14:03:50 -06:00
jason.woltje 17b972b92d feat(triage): the host holds the daily token cap
Each turn's usage goes to <dataRoot>/triage/usage.jsonl, one line per
usage.end, 0600 and owned by the running user; a link, wrong mode or
owner, or a non-file refuses. The host holds the stored cap through
daily-quota mayLaunch and report before each start and each queued
message, lets a crossing turn finish, drains the queue with a host
line, sums the file again after a restart (a torn line counts as an
unknown turn), and GET /api/triage adds usageToday, cap and resetsAt.
With no route stored the fields say "not set". cli.mjs keeps route
null. (#1873, lane triage-cap)
2026-11-18 14:03:50 -06:00
jason.woltje d531d7181d fix(triage): review round for the triage key verbs
- The grace is the earliest retire time, not a timer: rotate, status and the
  README say the old key stays live until retire runs after it.
- A temp file left by a kill before the rename is removed under the lock by
  the next issue, rotate or retire; status counts it.
- The receipts file is checked under the lock before any change
  (triage-key-receipts-unsafe); a receipt that fails after the change is
  triage-key-unrecorded.
- A failed directory sync after the rename is triage-key-unsynced, after the
  receipt is written, not triage-key-unwritten.
- proxy-lock-busy points at mosaic proxy fence status.
- Tests: a sentinel lost on the read-back, FIFO key and receipts files, a stale
  lock reaped, a crash before the rename, the receipts checks, the sync
  failure; the no-op assertion is gone. (#1873)
2026-11-18 13:54:13 -06:00
jason.woltje 67e1ff193d feat(triage): mosaic triage key issue|rotate|retire|status, Triage's own model proxy key
issue adds one mst-<tag>-triage- key under the instance proxy lock (read,
sentinel, re-read, fence, PUT, read back, confirm) and writes it to
<configDir>/secrets/triage/model (directory 0700, file 0600, the running
user's; a link, a non-file, a second link, a wrong mode or owner refuses).
rotate adds a new key and keeps the old one until now plus the bus's
rotateGraceMinutes from proxy.json; retire removes retiring keys once due.
status reads the file and the list, takes no lock and writes nothing.
Outputs, errors and receipts carry key ids only. A crash at each step
leaves a state status names and the next verb clears. Org and no-org bus
reconciles leave the key alone. Nothing wires the key into the host (#1873)
2026-11-18 13:54:13 -06:00
jason.woltje 9a3004cba4 test(webui): the agents.js export pin names the restart chain SP19 adds for the agent drawer (#1873, lane sp19-drawer-restart) 2026-11-18 13:15:20 -06:00
jason.woltje 4b833d23e9 fix(webui): drawer restart review round: each restart keeps its own state per agent, so another drawer's Stop or question no longer drops its line or its running state, with a two-drawer test; once the agent was ended (a refused launch, a thread ended, a restart done) the drawer repaints from a fresh instances read and focus goes to its heading, so an agent with no run no longer offers Stop and Restart; a refusal before the end keeps focus on Restart; an archived or unavailable organization says so instead of outcome unknown, with a test (#1873, lane sp19-drawer-restart) 2026-11-18 12:51:38 -06:00
jason.woltje 05be6c62bd feat(webui): Restart in the agent drawer: beside Stop and only where Stop is offered, in Stop's confirm step and status line, it ends the agent through its own organization's /agent/terminate with the reason restart from the agent drawer, waits for the request to close and its runs to reach 0, then launches it through /agent/launch; a conversation agent is ended and not launched; it never regenerates; not owner, bus stopped, end refused, launch refused and runs never reaching 0 each say so in one line and leave the buttons usable; a second click while it runs does nothing. The agents.js restart chain takes org, reason, a text callback and a status callback; the Routing receipt's Restart now keeps its reason and words, pinned by two new tests (#1873, lane sp19-drawer-restart) 2026-11-18 12:35:34 -06:00
jason.woltje c9fad00d25 fix(triage): review round for the route store
The file owner check has its own test through a file-owner seam, for
route.json on read and write and for route-receipts.jsonl on write. The
directory, temp file and a new receipts file get their modes on the open
descriptor, so a narrow umask cannot leave a route the next read refuses;
an existing receipts file is never repaired. A failed temp write refuses
and removes the temp file. A failure after the rename refuses as
triage-route-unrecorded and names the new revision. The input zone check
uses the stored cap's rule, so +05:00 refuses as an unknown zone. A
changed cap keeps its since, as an organization's token limits do, so
lowering the cap never drops tokens already counted (#1873, lane
triage-route-store).
2026-11-18 12:05:07 -06:00
jason.woltje 4c8527fcd3 feat(triage): the owner-only route store and mosaic triage route show|set
<dataRoot>/triage/route.json holds Triage's model route and daily cap as names only:
a catalogue model key, a harness name and a daily-quota cap leaf, with no env value
and no key. The directory is 0700 and the file 0600, owned by the running user; a
link, a hard link, a non-file, a wrong mode or owner, an unknown field or an unknown
time zone refuses. A write is compare-and-set on revision under an exclusive lock,
atomic (temp file, fsync, rename, directory fsync), and appends one receipt line.
The reset is 00:00 in a zone the owner gives, with no default. The file location,
field names and reset rule each live in one place.

mosaic triage route show|set are human verbs and refuse an agent run before any read.
Nothing is wired into the Triage host: the Console keeps route: null. Held for
Jason's ruling on the design's four questions (#1873, lane triage-route-store).
2026-11-18 12:05:07 -06:00
jason.woltje 2d44750b96 fix(webui): drawer polish review round 3 notes: with the runs not read and no claim, Last activity names the agents and claims reads, with a test for chief; the Project scroll test waits for the Projects page heading; a test comment matches the one of its runs wording (#1873, lane sp18-drawer-polish) 2026-11-18 11:26:45 -06:00
jason.woltje 9343baffff fix(webui): drawer polish review round 2: the kept scroll place is dropped as soon as the address leaves the page under the sheet, so a project or Assistant page that bus.js draws without afterPaint no longer leaves it for a later page; the scroll tests make every page long first and wait for the linked page's own content; Last activity says one of its N runs, and a run when the runs were not read (#1873, lane sp18-drawer-polish) 2026-11-18 11:18:18 -06:00
jason.woltje 38ea639d70 fix(webui): drawer polish review round: at 390 the page under the sheet goes back to its place only when the drawer closes onto that same page, so a link in the sheet opens its page at the top and a later page does not jump; Last activity counts a role or conversation claim only when the instances read lists its run as running, says when a running run holds nothing yet, and names the latest of several runs (#1873, lane sp18-drawer-polish) 2026-11-18 11:18:18 -06:00
jason.woltje fc558df31a fix(webui): drawer and page polish: at 390 the open agent sheet is the whole screen and the page under it no longer scrolls behind it, and Close puts the page back where it was; the drawer's Last activity is when the agent's current run took its role or conversation, from the claim time the workspace read already carries; the Dashboard's two columns line up with its tile row; the organization page's left column holds Autonomy and Starter packs; the workflows section() stub and its duplicate stopped panel are gone (#1873, lane sp18-drawer-polish) 2026-11-18 11:18:18 -06:00
jason.woltje 56cc7b59dd fix(seat,unslop-hook): review round: the linked fixed path test puts the stand-in's real path outside HOME so only its own guard refuses the source; the Stop hook's notes name the late-fallback turn a later Stop can check again and say a second Stop after a blocking hook waits and logs one late entry; the plugins README names the Perl, Ruby, less and resolver hooks and points to REFUSED_NAMES (#1873, lane triage-p3s) 2026-11-18 11:05:35 -06:00
jason.woltje c641dbfbc9 fix(webui): the triage snapshot reads every organization's bus and processing sockets at once and limits only the config checks, which start node children; the deadline tests count reads and use the injected clock instead of tight wall-clock margins (#1873, lane triage-p3s) 2026-11-18 10:52:53 -06:00
jason.woltje eb1146ebad fix(webui): a triage reply settles its entry only when it is the runner's RESULT answer; a progress note that names the message leaves it queued, so a session that dies after the note still reports it unanswered (#1873, lane triage-p3s) 2026-11-18 10:52:53 -06:00
jason.woltje 4b5d027361 fix(seat): hosted route fences P3s: realOr runs once per fixed path, a test hook adds a stand-in fixed path so a linked one is tested, the refuse list adds LUA_INIT, CURL_HOME and SSLKEYLOGFILE, and the plugins README names every refused suffix and hook (#1873, lane triage-p3s) 2026-11-18 10:52:53 -06:00
jason.woltje 80ce06851d fix(unslop-hook): the Stop hook records the last prompt it checked per session in <log>.stop.json and waits while the transcript still ends with that turn, so a Stop with no last_assistant_message, or one whose reply has the last turn's text, no longer checks the last turn as this one; the 2 s wait stays (#1873, lane triage-p3s) 2026-11-18 10:52:53 -06:00
jason.woltje b39d5e2ff3 fix(unslop-hook): review round, the Stop fallback logs late: true and the comment names the two stale cases left: an input with no last_assistant_message, and a reply whose text equals the last turn's last reply; cli.mjs notes that the packs-http read is the tested gate for system-only templates (#1873, lane triage-followups) 2026-11-16 16:05:43 -06:00
jason.woltje c85c768a4a fix(webui): the first render's heading focus leaves an open drawer or dialog alone: a reader who opened the Triage drawer, an agent drawer, the narrow-screen menu or a dialog before the first render ended keeps focus there; on load a second render can draw the agents rows while the first still reads, so the agent drawer had the same fault (#1873, lane triage-followups) 2026-11-16 15:54:12 -06:00
jason.woltje b7649ecd73 fix(webui): the workflows read leaves out system-only templates
The workflows read listed the triage template, which only the client hid.
The read handler now drops every template the organization vocabulary marks
system-only, and the Console's read supplier in cli.mjs drops them too. The
client filter stays. (#1873, lane triage-followups)
2026-11-16 15:46:57 -06:00
jason.woltje 0354452971 fix(unslop-hook): the Claude Stop hook waits for the turn to reach the transcript
Claude Code 2.1.319, 2.1.322 and 2.1.325 can run the Stop hook before they
write the turn to the transcript. The hook then read the last turn's reply,
logged it a second time, and missed this turn's reply. That made
claude-session.test.mjs row 66 red in most runs.

The hook now reads the transcript again, for up to 2 s, until its last reply
matches last_assistant_message. If it never does, it checks
last_assistant_message alone with an empty entryId, never the last turn
again. (#1873, lane triage-followups)
2026-11-16 15:45:09 -06:00
jason.woltje bbbefb3f28 fix(webui): triage fences re-check, only HOME may hold the stack's code: the code root names its holder, which must be a protected path, and no other protected path sets a source aside; a code root in or around the run dir or a fixed path is refused in either path's real spelling too; the mount, install root and protected lists are copied once so a changing list cannot pass one check and feed another; the refuse list adds PERLLIB, LESSOPEN, LESSCLOSE, HOSTALIASES and names ending _ASKPASS, _CA_BUNDLE or _BASE_URL (#1873, lane triage-fences) 2026-11-16 15:34:31 -06:00
jason.woltje 2f91ff5bea fix(webui): triage fences review, HOME is not counted against the stack's own code: a caller's protected path that holds the code root sets aside a source whose named and real paths both lie in it, never the run dir or a fixed path, so pi starts from a copy or worktree under HOME; a refusal at the binds answers triage-route-invalid and removes what the start wrote; each mount field is read once and no dest lies in or around another; values refuse every C0 and C1 control and U+2028/U+2029; the token shape drops the m flag; the refuse list adds MALLOC_, NPM_CONFIG_, XDG_, names ending _DIR, _CONF or _CONFIG, and the libc, shell, OpenSSL and Java hooks (#1873, lane triage-fences) 2026-11-16 15:34:31 -06:00
jason.woltje 1ca3a38f86 feat(webui): triage fences, the host checks a copy of the route's answer before anything is written or spawned: harnessEnv names must be declared by the harness module and are refused outright when MOSAIC_, NODE_, LD_, DYLD_, PYTHON, BASH_, GIT_, PATH, HOME, TMPDIR, ENV, a founder or a provider name; values are short clean strings; route env holds only the proxy's two names with a loopback base URL, and the host's port and token shape when given; the adapter and at most 8 mounts resolve inside the module's install roots and never in or around the data root, the config dir, HOME, /srv/mosaic or a secrets path, with dests clear of /tmp, the run dir and the system binds, checked again in hostedBinds; a refused answer answers triage-route-invalid and leaves a host line (#1873, lane triage-fences) 2026-11-16 15:34:31 -06:00
jason.woltje cb80b2b8a8 fix(webui): triage drawer re-check notes, a scrolled-up reader keeps the right one of two identical lines in view, the unsafe-directory answer no longer says Triage did not start since it can come while a session runs, and the text cleaner removes every default-ignorable character (#1873, lane triage-drawer) 2026-11-16 15:04:49 -06:00
jason.woltje fd300b4fe3 fix(webui): triage drawer review, a scrolled-up reader keeps the line in view when the oldest lines drop at the 200-line cap, a failed start says the message is in the conversation and was not delivered, a read that turns sending off hides the box and keeps the draft, and the text cleaner removes every control, format, separator and invisible character (#1873, lane triage-drawer)
The test helper opens the drawer after the page's first render has focused its heading, as a person
would. A drawer opened before that loses focus to the heading (bus.js); that is left as a follow-up.
2026-11-16 14:51:27 -06:00
jason.woltje a88302d6eb feat(webui): triage drawer, the instance owner opens Triage from the top bar and reads its state, health and transcript, and sends a message when the route allows it; nobody else gets the entry, the markup or a request (#1873, lane triage-drawer)
The drawer reads GET /api/triage only while open. A poll keeps the draft and the reader's scroll place.
Every field is set as text. Cards show the command with no Run button, and the dropped count.
The send box shows only when config triageSend and the read's send are both true. It names each
answer in plain words, never resends, and keeps the draft after a refusal.
Workflows: Save with only the state changed in an add form says the step is not added yet and keeps
the form. The step picker no longer offers the system-only triage template.
2026-11-16 14:36:07 -06:00
jason.woltje 820f45e474 fix(webui): triage final review, a reply names only a message id the host issued: the relay keeps in_reply_to only when it is an owner message id and drops anything else, so no model-written string reaches the transcript or the GET unchecked; the text cleaner also removes U+061C, U+180E, U+2028, U+2029 and U+FEFF (#1873, lane triage-host) 2026-11-16 14:05:46 -06:00
jason.woltje 2e9a2068bd fix(webui): triage re-check, the organization reads share one deadline, a reply that names its message answers it, every queued message leaves the queue with a host line when the session ends, and a launcher that cannot run is a failed start (#1873, lane triage-host) 2026-11-16 13:23:41 -06:00
jason.woltje fe6c22e0f2 fix(webui): triage-host review, the owner reaches the routes on an organizations Console, a second start answers, an unanswered or undelivered message gets a host line and leaves the queue (#1873, lane triage-host)
P1-1: the organizations branch lets the instance owner's own session through to the two Triage paths;
everyone else still gets this Console's unknown /api/ answer.
P1-2: each start clears turns/, so the runner's numbered turn files do not collide on restart.
P2-1: on exit, a message the session took and never marked read leaves the queue with a host line.
P2-2: member, signed-out, organizations-Console and org-selected route tests.
P3-1: bus-start cards carry --dev-local-owner on a dev local owner Console.
P3-2: a failed start writes a host line; the queue index is guarded.
P3-3: one shared refresh, a unique temp name per write, four organizations read at a time.
P3-4: the restart path waits for stop() inside its two-second exit.
P3-5: ANTHROPIC_API_KEY no longer passes from the route.
2026-11-16 13:23:41 -06:00
jason.woltje 9eed814d3c feat(webui): triage cap, the host holds the route's over-cap answer until its time (at most two days ahead, ISO only) and refuses without asking again; the read shows overCapUntil and a plain cap message (#1873, lane triage-host) 2026-11-16 13:23:41 -06:00
jason.woltje 7ee606cda2 feat(webui): triage routes, GET /api/triage and POST /api/triage/message for the instance owner only; everyone else gets the unknown-route answer, the write needs --send and the same-origin checks, production wires no route so the read says not set (#1873, lane triage-host) 2026-11-16 13:23:41 -06:00
jason.woltje b2d52b57c1 feat(webui): triage host and relay, a sandboxed session on the owner's first message (#1873, lane triage-host)
The Console holds <dataRoot>/triage/ (0700): health/ mounted read-only at
work/health inside the session, agent/ the session's own run directory, and
host/ with the 0600 transcript and the runner's log, never mounted. The seat
package's new hostedBinds and hostedArgv give the session the system part,
the runner's files, the adapter and those two directories, and nothing else
of the data root: no org root, bus socket, config or secrets, and no git
identity. Each source inside agent/ is made fresh at start (rm never follows
a link), and hostedBinds refuses a link in place of any of them.

The spawn environment is PATH (fixed), LANG, LC_ALL, TZ, TERM and the
route's ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY; bwrap
sets HOME and TMPDIR. A route answer whose harnessEnv names MOSAIC_CONFIG,
a MOSAIC_BUS_ variable or a founder credential variable is refused.

The relay is the only broker the runner reaches. It answers the runner's
lifecycle verbs with fixed answers, hands over the owner's messages, and keeps
a message.send only when it is addressed to "human": its text goes to the
transcript with its cards checked. Every other verb, a send to anyone else
and a call without the capability are refused with triage-refused.

The model route is injected; without one nothing launches (triage-no-route),
and a route over its cap refuses with triage-over-cap and its until. The
tests run the session end to end under bwrap with a stub adapter.
2026-11-16 13:23:41 -06:00
jason.woltje cbf1836bd7 feat(webui): triage health snapshot and command cards (#1873, lane triage-host)
The snapshot is one 0600 JSON file with a fixed field list: the Console's
answer, the model proxy unit, the system config check, and each active org's
bus state, last start, processing and org config check. States, times, counts
and codes only; a read that fails or hangs says "not read". The system config
check runs scripts/mosaic-config.mjs validate in a child with stdout ignored and
keeps the exit code and one fixed refusal code; the org config check keeps its
exit code only. Cards are { step, org } with a known step and a registered org;
the server renders the command and drops anything else.
2026-11-16 13:23:41 -06:00
jason.woltje 6fe3625fae fix(webui): sp17 review 2, a new step typed in the add form is not dropped by Save: the bar's Save with a typed new step says it is not added yet, keeps the form and puts the caret in its title, and an add form with nothing typed is closed and the rest saved; test types a new step and presses the bar's Save, sees the words and no write, then adds the step and sees all three in the write (red before: Save wrote without the new step and said Saved); the pack apply test waits for the autonomy read as well as the workflows read, as it answered later on a loaded host (#1873, lane sp17-workflow-clicks) 2026-11-16 12:36:33 -06:00
jason.woltje 24551c9eea fix(webui): sp17 review, no edit is dropped without a word: an open edit of one step goes into the pending workflow as typed when another step is drawn or typed in (a card step link, the address or Back opened it), so Save sends both and Reset step on the second puts back only that one, and a step the save check refuses is named by Save, which checks every step; while a Save or delete is in flight the step and workflow forms' fields are off, drawn off when busy and set off on a held form, and on again after the answer or a refusal, so nothing typed then is lost when the form is drawn again; tests open step 2 from the card and from the address with step 1 changed and see both in the write (red before: step 1 went back to Build), and check the fields are off during a held write and a redraw and on after it and after a refusal (red before: the fields stayed on) (#1873, lane sp17-workflow-clicks) 2026-11-16 12:36:33 -06:00
jason.woltje cad9cd057f fix(webui): sp17 shots, the path reads right at 390 and in both modes: a step link lands with the title and the Save under it both in view (at 390 Save was below the fold), a Save with nothing to save is drawn off rather than in the action colour, and after Save the focus stays in the form it was saved from so the line saying Saved stays in view (at 390 the jump to the graph node put it off screen); the three-clicks test checks the title, Save and the Saved line are in view and the focus is kept (red before: Save in view at 390, and the focus and Saved line on three of four cases) (#1873, lane sp17-workflow-clicks) 2026-11-16 12:36:33 -06:00
jason.woltje 4f24501801 fix(webui): sp17 one field of one step saves in three clicks, one workflow editor, and an edit kept through a bus restart: each workflow on the organization's Workflows card lists its steps as links, and a step link opens that step's form with the caret in its title, so the path is the organization in the sidebar, the step on the card, Save (3 clicks at 1440, 4 at 390 with the menu, 2 from the organization's own page; it was 6); Delete keeps its confirm; the old form editor on the organization page and its rules are gone, since the graph page's step and workflow forms cover each field it changed; a failed workflows read keeps drawing the last read with the pending change and says the read failed; a poll keeps an open step form whose step another writer did not change; the card names each held change with a link back to it, also while the bus is stopped, where it said only that the bus was stopped; tests count real pointer clicks on the path, open a step edit through a bus restart, a stop and a return, and press Restart bus with an edit held, and save it after (red before the card note: the stopped card did not name the edit) (#1873, lane sp17-workflow-clicks) 2026-11-16 12:36:33 -06:00
jason.woltje 02e053866a fix(webui): sp17 a Save in flight holds the workflow poll: each organization counts its workflow writes, and a read that began before a write ended, or answers while one is in flight, is dropped so it cannot draw the file from before the Save over the saved step; the page takes the saved workflow and the revision from the write's answer instead of reading again; the test holds the write, starts a poll whose read holds the old file, lets the write answer and then the read, and sees the saved title and a second Save on the answered revision (red before the fix: the step went back to Ship) (#1873, lane sp17-workflow-clicks) 2026-11-16 12:36:33 -06:00
jason.woltje ff096afa27 fix(webui): sp16 review 3, a kept packs answer of no use for this hire is read again at once: a refusal or no answer is read again on each render, at most one read open, so the template line recovers with the route instead of saying not read for 60 s; an answer that does not name this hire (a hire made after it was read) is read again once per hire until the keep runs out, and the line says the template is being read, not that the pack does not name it, until that read answers and repaints the drawer; a hire the pack really does not name says so after one read and makes no read on each repaint; the drawer's second look after its race starts no read, so a render makes at most one packs read; the quiet refresh at 60 s still draws the kept answer with no swap; tests pin a later hire, a hire the pack does not name, a 503 that recovers and the 60 s refresh (#1873, lane sp16-drawer-actions) 2026-11-16 12:01:02 -06:00
jason.woltje 70af20e29d fix(webui): sp16 review 2, the drawer shows the state as soon as it is read and the template line holds still: when the instances read answers after the page, the drawer repaints at once with the state, and a pack hire's template line says being read until its packs read answers and repaints it (data-drawer-pending names <n> for the instances read and <n>p for the packs read, and a repaint waiting on the fresh drawer runs at the swap); the packs answer is kept per organization for 60 s and a repaint draws from it, also while a newer read is open, so the line no longer goes back to being read on every poll and one read serves the repaints; a drawer whose reads have all answered is no longer marked pending and swapped after paint; the Role row of a pack hire says Hired and the pack is named once, in Hired from; the unreachable holds-no-conversation line is gone; Last activity for a conversation agent reads not shown: reading it means reading the whole conversation; tests pin one packs read across three repaints, the state shown while packs is held, and no pending marker when all reads are in (#1873, lane sp16-drawer-actions) 2026-11-16 11:46:38 -06:00
jason.woltje d92cdefc1d fix(webui): sp16 review, the packs read never holds the page and never breaks the drawer: a pack hire's packs read is raced against the page's reads as the instances read is, so a slow one shows the template as being read and repaints the drawer when it answers, and the instances read is let go once it answers so a held packs read never keeps a stale state; a packs answer that is not JSON says not read: no answer instead of leaving no drawer; Hired from names the pack by the label the installed pack carries, since the instance names only its id (the test stub now gives the instance the bus's shape); Last activity for an agent holding a conversation says the drawer does not read it, since that thread's messages read pages from the oldest message, and not recorded stays for the rest; where no Message is offered the line says the state is being read, gives the reason a failed read gives, or says a copy is not messaged from here; a 401 reads as signed out (#1873, lane sp16-drawer-actions) 2026-11-16 11:46:38 -06:00
jason.woltje 9994f89790 feat(webui): sp16 the agent drawer says what it can about an agent and why it can not act: Last activity reads not recorded, since no read the Console makes carries the time of an agent's last message or run (the agents read's time is the role claim, since the start of its present state); a pack hire shows Hired from with its pack and the template the installed pack's hire names, from the existing owner-only packs read, made only for a pack hire, and says not read with the reason when that read is refused; where no Message is offered one line says why; a drawer whose instances read answers after its HTML is built and before the page carrying it is on screen repaints once that page is painted, instead of staying on Reading state until the next poll; the organization page's Workflows card moves under Active agent sessions so the left column is not empty below the sessions. No Restart: no route restarts one agent (#1873, lane sp16-drawer-actions) 2026-11-16 11:46:38 -06:00
jason.woltje 4a9c7a931c feat(organization): triage is system-only, no organization gains it (#1873, lane triage-fence)
One list, SYSTEM_ONLY in vocabulary.mjs, names triage; every path by which an
organization could gain one refuses with the one code template-system-only:
hire prepare at org, project and root level and a change onto it (hire.raise,
hire.start.console, decision.raise naming role.hire or role.change); the hire
and definitions template lists omit it; definition import; a definition copied
from it; organization roles, root agents and project agents; a pack record
pinning it; a starter pack defining it, so pack preview and apply refuse an
installed pack that names it; instances.set add and change for the human and
the tester, and the instances add list omits it. The broker passes the code
through and the webui tables map it. The template itself still loads and
validates. Red-first tests in organization and bus system-only.test.mjs; the
channel-proof hash of webui bus.mjs and the broker import pin are updated.
2026-11-16 11:38:17 -06:00
jason.woltje 5c7194e05b feat(roles): triage template, read-only and human-only, from parts the shipped templates use
roles/triage.json: read, grep, find and ls; network none; message.send within role and nothing
cross-role; no credentials; messaging to and from the human only. Every grant is a subset of the
chief of staff's, so no line is flagged above the chief. No web grant, so the REQ-HARN-2 pin holds.
roles/triage.md: Triage reads health, explains, and proposes existing mosaic verbs as cards the
person runs. It never hires, raises a hire, applies or drafts a pack apply, or reads a secret; of
the system config it reports only whether the check passed. Carries the proactive line every
contract pins. Template only, per Jason's 2026-11-16 ruling; no new grant, verb or transport.
2026-11-16 11:16:20 -06:00
jason.woltje f0bf85befe docs: record the 11-10 to 11-15 landings, starter packs, the pack apply decision and single pane sp1 to sp14 (#1873)
Appends six docs/SESSIONS.md lines (2026-11-10 to 2026-11-15, actor Sage
(Lead)), three BUILD-LOG.md phase entries (starter packs replace system
types; applying a pack is the hire decision, with the route fallback and
the exit 127 fix; single pane sp1 to sp14 with the sp15 correction) and
one docs/plans/CURRENT.md completed-log entry on the single pane state at
c26879637. Sources: uidev/LEAD-1110.md and git. Append only; no existing
line changed. Lane docs-1116.
2026-11-16 11:05:52 -06:00
jason.woltje c26879637a fix(webui): sp14 review, every drawer opened while its instances read is open repaints when that read answers: the pending drawer names the read it waits on, and each open repaints its own drawer if it still waits on that read, so a second agent opened before the answer no longer says Reading state until the next poll; the Settings card's Agents and roles row uses the same running-not-read check as the Active agent sessions heading, copies included; test opens chief while coder's read is held and sees chief's state at once (#1873, lane sp14-org-page-truth) 2026-11-15 13:52:25 -06:00
jason.woltje 2fc97a3edb fix(webui): sp14 the organization page tells the truth: the Queue card and its queue read are gone (the Queue page stays at #/queue); an instances answer in which no agent carries runs says running was not read on the Active agent sessions heading and body, the Agents working tile and Settings' Agents and roles row, and on the Dashboard the Agents working tile leaves that organization out and names it while its row says running not read, never 0; the Assistant's kept pane messages are stored with an opaque viewer the /api/config read now names and are read back only under the same viewer, so a second person on the same tab, or a store from before, opens empty; the drawer's instances answer repaints only the drawer from the reads it already has, so no page read is made again (15 requests before, 0 now); a full Assistant set disables its picker at mount (#1873, lane sp14-org-page-truth) 2026-11-15 13:38:09 -06:00
jason.woltje 68df55130e fix(webui): sp13 review, a drawer closed before its instances read answers keeps no answer for the next open: the answer is dropped when no pending drawer is left to repaint, so a later open reads again instead of showing a state from minutes before; test closes the drawer while its read is held, lets the read say nothing runs, reopens and sees the agent working (#1873, lane sp13-org-page-fit) 2026-11-15 12:54:28 -06:00
jason.woltje 6ad1d33dd1 fix(webui): sp13 shots, the organization page's two columns start level: the Workflows card wraps its heading, so the split's first-heading rule did not reach it and that column started 22px low beside the other and 22px apart when stacked; the fit test checks both first headings start level at 1440 (#1873, lane sp13-org-page-fit) 2026-11-15 12:44:04 -06:00
jason.woltje 5fba4726dc fix(webui): sp13 the organization page fits its width: its two columns wrap to one once the content is narrower than both need, with or without the agent drawer, and the Settings card puts a value on its own line when the card is narrow, so no value or Open link is cut; #/orgs/<id>?query is the organization page with the query kept and ?agent= opens the drawer; the drawer says its state is being read while the instances read is open and that it was not read when that read fails, never not running, and its Stop note says the same; an instance whose runs were not read shows state not read on the Agents table; the Queue card says in plain words when this Console does not run from the checkout that holds the queue and drops Open queue there (#1873, lane sp13-org-page-fit) 2026-11-15 12:34:30 -06:00
jason.woltje 69ce460f91 fix(webui): sp12 review, the agent drawer holds at most one history entry: a row opened from the page pushes one marked entry, another row replaces it, the open row changes nothing, and Close goes Back only from that marked entry, so a shared link never leaves the Console; Escape while Stop asks cancels only the question; the Tasks board drops the assignee filter the address set when the address drops it; tests cover a Stop the bus takes (#1873, lane sp12-agent-drawer) 2026-11-15 11:46:19 -06:00
jason.woltje 307f88be3e fix(webui): sp12 shots, at 1200px wide and above the page keeps clear of the agent drawer so nothing sits under it; where this Console could change the organization's agents but Stop is not offered, the drawer says why (a copy, a protected agent, or not running); drawer sections drop the page section margin (#1873, lane sp12-agent-drawer) 2026-11-15 11:35:48 -06:00
jason.woltje bfd3ed6811 feat(webui): sp12 agent drawer, selecting an agent on #/agents or in an organization page's Active agent sessions opens its details at the right of the page with ?agent=<org>:<name> in the address; Back, Escape and Close close it and focus returns to the row; fields come from the workspace, instances and business reads; Message and Stop follow the organization's own config, Stop asks first and says why a refusal happened; the Tasks board takes an assignee from the address (#1873, lane sp12-agent-drawer) 2026-11-15 11:21:32 -06:00
jason.woltje 5b6b39f080 test(webui): sp11 item 3, the w15 fixture answers the bus instances read the conversation page now makes, with no rows, so Resume shows as before and the read is not counted as unexpected (#1873, lane sp11-fixes) 2026-11-15 10:27:28 -06:00
jason.woltje 2d7d7be5ca fix(webui): sp11 review 2, the Sign out form drops kept pane messages as an expired session does, and the page it unloads keeps none; when neither bus read gives agent activity, an organization page's sessions heading says working was not read instead of a figure (#1873, lane sp11-fixes) 2026-11-15 10:27:28 -06:00
jason.woltje f73c761ad3 fix(webui): sp11 review, signing out drops kept pane messages and stops keeping them; an organization page's sessions heading and rows take activity from the session list the Agents working tile counts, so the two agree; the Messages page test covers class words (#1873, lane sp11-fixes) 2026-11-15 10:27:28 -06:00
jason.woltje 8b4a26dd2b fix(webui): sp11 item 8, with no organizations #/dashboard is the Dashboard: it says there is nothing to count and offers New organization, which opens the Organizations form at its ID field; #/ stays the Console's own board (#1873, lane sp11-fixes) 2026-11-15 10:27:28 -06:00
jason.woltje 11d2b43b3a fix(webui): sp11 item 7, the organization header line beside the disabled reload says in plain words that the bus reads the organization file when it starts and a change loads on restart (#1873, lane sp11-fixes) 2026-11-15 10:27:28 -06:00
jason.woltje 8aefc0f7a9 fix(webui): sp11 item 6, an organization's decision page, decision list, replies and messages name a decision class in the Inbox's words from the same map; message classes the map does not know show as they are (#1873, lane sp11-fixes) 2026-11-15 10:27:28 -06:00
jason.woltje 9cff3255e6 fix(webui): sp11 items 4 and 5, a pane's unsent message is kept per thread for the tab's life and comes back when the pane opens again, Full view included; closing a pane with one asks first; a pane whose send waits for its receipt is held when a fourth thread opens (#1873, lane sp11-fixes) 2026-11-15 10:27:27 -06:00
jason.woltje d50d79cddd fix(webui): sp11 item 3, Resume assistant shows only when the bus instances read says the thread's agent runs no process; a failed read or an unlisted agent keeps the control (#1873, lane sp11-fixes) 2026-11-15 10:27:20 -06:00
jason.woltje fb3bd16052 fix(webui): sp11 item 2, Done this week opens the Tasks board filtered to the tasks it counted: done=week in the address keeps done tasks last changed in the past 7 days, a chip clears it, and the count line says the bus records no time a task was done (#1873, lane sp11-fixes) 2026-11-15 10:27:20 -06:00
jason.woltje 13615e12b9 fix(webui): sp11 item 1, agent counts say running and working and count the same rows: the tiles say how many run beside how many work, the Dashboard organization rows count the tile's rows, the sessions heading lists the running copies too, and the Agents page names a running agent with no reported state (#1873, lane sp11-fixes) 2026-11-15 10:27:20 -06:00
jason.woltje bd29e756a5 fix(webui): sp10 recheck notes, Apply clears a refused Save's line, and a refused Delete with no pending change does not point at Discard (#1873, lane sp10-workflow-edit) 2026-11-15 09:42:07 -06:00
jason.woltje 6bd9be78ac fix(webui): sp10 review round, Save refuses while a step form holds edits not applied, Delete sends the revision the page shows so a stale view is refused, Save re-reads into the current state, and a failed read or stopped bus says a pending change is kept (#1873, lane sp10-workflow-edit) 2026-11-15 09:36:30 -06:00
jason.woltje 3a84f46b6e fix(webui): sp10, the list page's read-only line gets the same spacing class as the graph page's (#1873, lane sp10-workflow-edit) 2026-11-15 09:27:58 -06:00
jason.woltje 208439814a feat(webui): sp10, edit a workflow in its step graph, held unsaved in the page with Save and Discard, one POST with the read revision, refusals in words with the change kept, a stale note when the file moved, new and delete workflow from the list, and the sp9 follow-ups (missing role on its own line, box fit by text extent) (#1873, lane sp10-workflow-edit) 2026-11-15 09:18:43 -06:00
jason.woltje 7c6571768f test(webui): sp9, the organization page's tab order names its right column Workflows and settings and reaches the All workflows link (#1873, lane sp9-workflows) 2026-11-15 08:31:10 -06:00
jason.woltje 3597e0daf6 fix(webui): sp9 review round, a step box lists its roles one per line (three at most, then "+N more"), clips its text to the box, and the step panel drops aria-live; tests press Enter on a step and check a four-role step stays inside its box (#1873, lane sp9-workflows) 2026-11-15 08:31:10 -06:00
jason.woltje 3116f43e65 feat(webui): sp9, an organization's workflows read only, a list at #/orgs/<id>/workflows, a step graph at #/orgs/<id>/workflows/<name> with the selected step's roles, state and neighbours, and a Workflows card on the organization page (#1873, lane sp9-workflows)
The graph reads the existing GET /api/orgs/<id>/workflows; no new route and no write.
A stopped bus shows the data-ws-unread note, never "no workflows". An organization
with none says so and links Apply a pack only where this Console may apply one.
At 700px and below the graph runs top to bottom inside its own frame.
2026-11-15 08:31:10 -06:00
jason.woltje c66f1ec00c fix(webui): sp8 review round, an organization page starts its workspace read beside its own reads, a Dashboard tile with no figures read says so, the Organizations heading gets its jump target from secH (#1873, lane sp8-kpis) 2026-11-15 07:56:00 -06:00
jason.woltje 9400e0d94d feat(webui): sp8, the Dashboard leads with one row of figure tiles and an organization's page with its own, each a link to the page that lists what it counts (#1873, lane sp8-kpis)
The Dashboard's tiles are Agents working of all agents, Organizations running, Needs you, Open tasks,
Done this week and Projects, each added up only from the organizations whose reads gave it; a tile
names every organization it leaves out and why. The Sessions and Model spend tiles go: the first is
the Agents tile now, the second had no figure. An organization's page replaces its KPIs and Metrics
placeholders with Agents working, Open tasks, Needs you and Done this week for that organization,
each a link to the system page filtered to it, from one cross-organization read scoped to it. The
system Agents page's row building is shared so a tile's figure is that page's row count.
2026-11-15 07:33:21 -06:00
jason.woltje a9912983e6 fix(webui): sp7 re-check, a narrow pane wraps its header tools inside the pane, the project page's Review decision and request links keep the conversation's full view, Full view names its thread (#1873, lane sp7-polish) 2026-11-15 06:41:07 -06:00
jason.woltje 626321608f docs(webui): sp7, the Assistant's header comment names the links that keep the organization's own view (#1873, lane sp7-polish) 2026-11-15 06:28:40 -06:00
jason.woltje 5f965cdb30 fix(webui): sp7 review shots, a pane header keeps its title, Full view, Messages and close on one row with the organization and project below (#1873, lane sp7-polish) 2026-11-15 06:27:19 -06:00
jason.woltje 8296d33100 fix(webui): sp7 review round, each pane links its thread's full view in one plain click, a requirement's Open conversation keeps the organization's own view, the gated-pill assertion matches its text (#1873, lane sp7-polish) 2026-11-15 06:24:39 -06:00
jason.woltje 69ac78b97e fix(webui): sp7 shots round, a pane header keeps its close button on one line, and a thread that was not opened is said as a warning (#1873, lane sp7-polish)
- assistant.css: the pane title shrinks before the header tools wrap, so the close button stays on the title's line at 1440.
- assistant.js: paintNote draws the line under the lead; a refusal marks it data-refused and the line shows in the warning colour until the next change clears it.
- assistant-threads browser test: the refusal line carries data-refused, and closing a pane clears it.
2026-11-15 06:03:06 -06:00
jason.woltje a2a7df73df fix(webui): sp7 polish, a system page names itself once, thread links open as Assistant panes, each pane links its organization's messages, resume is a small control, Inbox class chips use words, a stopped organization's page has one restart (#1873, lane sp7-polish)
- A system page with nothing above it in the trail hides the trail that repeats its h1; drill-in trails stay.
- A project's thread link and each open-in-chat link add that thread as a pane on #/assistant. With three
  open, the first pane without an unsent message is replaced; when all three hold one, nothing is
  replaced and the page says why. Per-org chat addresses still work typed or pasted.
- "Messages in <org>" moves from the bar into each pane header as a link.
- The pane composer's Resume assistant is a small secondary control; behaviour unchanged.
- Inbox class chips read the one map of decision classes to words.
- Removes the unused pane, idPrefix and views params from projects.js and workspace.js; fixes the stale
  comment on the held-message status line.
- While an organization's bus is down, the header draws no bus control; the down banner's restart is the one.
2026-11-15 05:55:26 -06:00
jason.woltje 789e2bcdd4 fix(webui): sp6 third review round, a held message line stays steady between polls, only a pane's latest render decides the line, the held preview cuts on whole characters (#1873, lane sp6-threads) 2026-11-15 05:02:28 -06:00
jason.woltje 02df2a3a25 fix(webui): sp6 re-check notes, a held message is never overwritten or held out of sight, and a pane whose organization left the list does not promise it comes back (#1873, lane sp6-threads)
The held draft goes back only into an empty composer and is cleared only once it is in it. A thread
that reads without a composer shows the held message in the pane's line. Only a stopped or
unavailable bus says the message comes back when the pane reads again.
2026-11-15 04:57:37 -06:00
jason.woltje b982404963 fix(webui): sp6 review round, a stopped organization's pane stops reading and keeps its unsent message, an open pane picks up new replies on its own, a pasted thread id in any case shows its pane (#1873, lane sp6-threads)
A pane whose organization's bus is stopped or unavailable no longer polls or offers Refresh; it says
nothing is read until the bus starts again, holds any typed draft, and restores it untouched when the
bus returns. Unsent pane drafts now count for the organization-switch and Console-restart guards.
The Assistant sidebar item drops the Messages unread badge. "Start thread" is the primary action.
Tests cover the stopped pane's draft, a reply arriving with no refresh, and an uppercase show id.
2026-11-15 04:51:23 -06:00
jason.woltje 5dd940165d feat(webui): sp6, the Assistant page holds up to three threads from any organization side by side, with the open set in the address (#1873, lane sp6-threads)
The sidebar Assistant opens one system page, #/assistant. Each pane is the
chat thread view of its own organization: it reads, sends and updates
through that organization's routes, with a header carrying the title, the
organization chip, the project chip and a close control. "Open thread"
lists the threads of every answering organization, grouped by organization,
and starts a new thread in a chosen one. The open set and its order live in
the hash (open=org:id,...&show=org:id), validated on read. A stopped
organization is named at the top and in its own pane; the other panes keep
working. At 390 one pane shows with a tab strip.

Side by side is removed (panes.js, panes.css and its test); its old address
lands on the Assistant page.
2026-11-15 04:37:52 -06:00
jason.woltje ed4f45ed23 fix(webui): sp4 third review round, a move still writing never paints the board over the not-on-your-list page, an archived project keeps its filter while another filter matches none of its tasks (#1873, lane sp4) 2026-11-15 03:54:28 -06:00
jason.woltje 79df01f1de fix(webui): sp4 second review round, a project filter stays while its organization does not answer, a gone filter is cleaned only from the address its read started on, a read in flight never paints over the not-on-your-list page (#1873, lane sp4) 2026-11-15 03:54:28 -06:00
jason.woltje d7b98b4698 fix(webui): sp4, an organization's own task board with no filter on no longer says its tasks match the filters (#1873, lane sp4)
The scope's org= in the workspace read is where the board reads, not a filter, so the
count line and the empty state no longer treat it as one. Found in the retaken shots.
2026-11-15 03:54:28 -06:00
jason.woltje 0f29fe0d92 fix(webui): sp4 review round, one organization chip per card with its avatar, a filter that is gone leaves the address, an impossible organization address is not the system board (#1873, lane sp4)
- The card's organization chip carries the avatar in place of its dot; the bare avatar
  before it is gone (prototype shot 13).
- A filter naming an organization or project that is not on the list is dropped from the
  address after the render, and a dropped project reads again without its server filter.
- #/orgs/<id>/tasks with an id no organization can have says "This organization is not
  on your list." instead of showing every organization's tasks.
- The write check's comment and the test's fake say orgSetup is Console-wide today.
2026-11-15 03:54:28 -06:00
jason.woltje 32be3a01bc feat(webui): one task board for every organization, with organization and project filters in the address (#1873, lane sp4)
#/tasks is a system route that shows every organization's tasks on one board,
with the per-organization columns, organization and project chips on each card,
and the organization and project filters kept in the address. An organization
that did not answer is named first with its reason. A move or edit goes to the
row's own organization and is offered only where that organization's own config
takes task changes. #/orgs/<id>/tasks is the same board scoped to one
organization, and a card opened from the system board links to its task there.
A render replaced by a newer one now draws from that newer read instead of
throwing on an empty board.
2026-11-15 03:54:28 -06:00
jason.woltje f97e0d3aeb fix(webui): sp5 re-check notes, a late named Fire leaves a newer Fire's busy state alone, the picked agent row gets the left bar, tests for the picked agent with the state filter and a refused scope (#1873, lane sp5) 2026-11-15 03:32:32 -06:00
jason.woltje eebdb2f0ce fix(webui): sp5 review round, Open addresses the agent and the scoped page marks it, Fire words name the organization, a named Fire keeps its outcome, Cancel restores focus (#1873, lane sp5)
- Open on #/agents goes to #/orgs/<id>/agents?agent=<key>; the scoped table puts that agent first,
  marks it (aria-current) and draws no Open or Actions column (review F1, F2).
- Fire's aria-label, confirm group and receipt use the organization's label (F5).
- A Fire sent to a named organization keeps its receipt after the opened organization changes (F7).
- Cancel moves focus back to the row's Fire (F10).
- agentsPage refuses a scope that is not an organization id instead of listing every organization (F11).
2026-11-15 03:26:18 -06:00
jason.woltje 5373b110ac feat(webui): one Agents page for the whole system, with organization and state filters, Fire sent to the row's organization (#1873, lane sp5)
#/agents lists every organization's agents in one table: name, role, state,
what each works on, organization and project chips. Org and state filters
live in the hash query. A stopped organization is named at the top. A row
opens the agent in its organization; Fire is drawn only where that
organization's own config lets this Console decide, and posts to that
organization's hire route. #/orgs/<id>/agents leads with the same table
scoped to one organization, above the levels grid and held roles. A hired
agent reads as Hired (or Hired from pack X) with its org:hire id as
secondary text. The sidebar and dashboard Agents links open the system page.
2026-11-15 03:13:54 -06:00
jason.woltje 3885f4628b fix(webui): sp3 second review round, #/inbox keeps the system theme, hire links follow each organization's own decide (#1873, lane sp3) 2026-11-15 02:09:04 -06:00
jason.woltje ba9933309b fix(webui): sp3 review round, answers from the system Inbox read route_to and show who raised them, the hire form is linked, the sidebar count stays system-wide (#1873, lane sp3) 2026-11-15 01:10:13 -06:00
jason.woltje 0785af8129 feat(webui): one Inbox for the whole system, with organization filters and answers pinned to the row's organization (#1873, lane sp3)
#/inbox lists every answering organization's decisions from the one GET /api/workspace read, newest
first, each row with its organization chip and a project chip when it has one. Organization and
type filters live in the hash query. A stopped organization is named at the top with its reason.
An answer from the list reads and posts to the row's own organization (/api/orgs/<org>/...), never
the one opened last, and each item can be opened in its own organization. #/orgs/<id>/inbox is the
same list filtered to that organization. No server route was added.
2026-11-15 01:10:13 -06:00
jason.woltje d1b01329bc fix(webui): sp2 polish, an organization's bare address opens its page and the dashboard keeps the system theme (#1873, lane sp2)
- #/orgs/<id> with no page and no trailing slash now opens #/orgs/<id>/organization instead of the
  system dashboard.
- The system dashboard resolves its own appearance (this browser's choice made
  there, else the default) under mosaic-console-appearance-system; it no
  longer shows the theme of the organization opened last.
- A stopped organization's page shows one bus banner: the page's own down
  banner now carries the restart action, and the shell's "Bus unavailable"
  banner hides on that page (display.js paintBus and app.js busDown).
- The dashboard row for a stopped organization no longer repeats "the bus is
  not running" under "bus stopped"; the last start time still shows.
- Organizations table figures keep to one line (white-space, no font change).
- The Active agents status cell was class "st", which picked up the global
  .st::before "?" glyph; it is now ws-st.
- Tests: red-first browser tests for each item, plus the test sp1 lacked: a
  read still in flight at an organization switch keeps nothing.
- org-switch-browser: a stopped organization's page asserts one banner; the
  shell's "Bus unavailable" is checked on its tasks page instead.
2026-11-15 00:44:18 -06:00
jason.woltje c7aecbffa9 fix(webui): sp1 second review round, a read or file save in flight at a switch keeps nothing (#1873, lane sp1)
The second review found two paths the first fix round left open.

- The project-file save captures orgEpoch before its POST. When a switch
  happened meanwhile, it neither paints nor announces the old file's
  outcome on the new organization's page. An opaqueredirect still signs out.
- A live read (reader, get.api), the palette's inbox and tasks reads and
  the board poll keep their answer in `last` only while the organization
  they were sent for is still open. A later cached render on the new
  organization no longer draws the old one's rows.

single-pane test 11 holds acme's file save across a switch to beta and
asserts nothing is announced: red on the previous bus.js ("Saved as commit
cccccccccccc."), green now. The kept-read guard has no browser test.
2026-11-14 23:51:59 -06:00
jason.woltje bb2f79f3d9 fix(webui): sp1 review round, a switch carries nothing across and first run keeps its board (#1873, lane sp1)
- First run (no organization yet) keeps #/ as its board; the router no longer rewrites it to
  #/dashboard, which first run cannot draw.
- An organization switch stops the agents section's request poll and clears what it held. A
  route-change restart chain finishes on the organization it started in.
- A write in flight at a switch drops its answer: an org epoch in bus.js, checked after each
  await. The switch clears every busy flag, receipt and reply, and the doc drafts.
- The bus banner reads org state again only when the route crosses /dashboard, not on every
  hashchange inside one organization.
- The down banner does not repeat its heading as the reason.
- Tests: first run wordmark, poll stop on switch, restart pinned to its organization, settings
  save in flight at a switch, banner without a repeated reason. The org-switch test comment and
  wait match the in-place switch.
2026-11-14 23:19:05 -06:00
jason.woltje e24e7e93a2 feat(webui): one shell, a system dashboard, organization pages as drill-ins (#1873, lane sp1)
#/dashboard is the system landing route: one row per organization with its bus
state, agent count (organization files), project count and needs-you count,
each only when a read gave it, and active agents. Opening an organization from
the sidebar or a dashboard row is a route inside the same page: no reload, a
Dashboard / <organization> breadcrumb, and later /api reads scoped to it through
the existing fetch wrapper, whose organization is now a variable the router sets
(mosaic-org-switch event). #/orgs/<id>/... stays the address. An organization
whose bus is down says so on the dashboard and on its page, with the reason the
workspace read gives.
2026-11-14 22:35:00 -06:00
jason.woltje 387f73a7a4 fix(harness): r127 review round, only a shell's own not-found line names a program (#1873, lane r127)
Review P3-1: a "No such file or directory" line from another program
(cat, ls) no longer counts. Only bash's "line N:", dash's "N:" and env's
quoted form do.
P3-2: a name with a run of 16 letters and digits looks like a key, so it
stays in the run's private stderr instead of the reply.
P3-3: a 16 KiB stderr window that starts mid-file drops its partial first
line, so a cut name ("aude") isn't reported.
P3-4: CRLF lines read the same as LF lines.
P3-5: tests for the name check (tokens without spaces, key-shaped names),
for a cat line, and for the window boundary through the runner.
2026-11-14 21:19:02 -06:00
jason.woltje 61371adb10 fix(harness): an adapter exit 127 names the program that wasn't found (#1873, lane r127)
A claude-code turn on a Console started without MOSAIC_CLAUDE_BIN failed
with a bare "adapter exited 127". The sandbox binds /usr, so the wrapper
/usr/bin/claude is visible, but its exec target /opt/claude-code/bin/claude
isn't bound, and the shell exits 127.

On exit 127 the runner now reads the tail of the turn's stderr, finds the
shell's "not found" line (bash, dash, env) and adds the program's basename:
"adapter exited 127 (command not found: claude)". It never shows a host
path or anything that isn't a plain program name; a 127 without such a
line keeps the bare reason.

The deploy side (MOSAIC_CLAUDE_BIN on the Console unit) is a Lead-owned
script change, written up in the lane report.
2026-11-14 21:07:14 -06:00
jason.woltje b913f0f4c8 fix(bus,webui): pr2 review round, WebUI receipt carries routeFrom, design note, member and project tests (#1873, lane pr2)
The WebUI packs receipt passes routeFrom through on each hire line; the WebUI
README and TOOLS.md name it. The starter packs design doc gets a dated note
for the 2026-11-14 route ruling. New bus tests: a member pack hire on the
assistant route marks hired and awaiting-owner lines routeFrom assistant, and
a project pack with no chief route hires into the project on the assistant's
harness and model.
2026-11-14 18:37:28 -06:00
jason.woltje bfd2cc5e79 fix(bus,cli,webui): a pack hire falls back to the org assistant's harness and model (#1873, lane pr2)
pack.state gave a pack hire only the chief of staff's resolved route, so an
org whose chief has no model refused every hire pack-hire-route-missing. The
route is now the chief's (launch.by), else the org assistant's (the instance
whose definition is assistant; the one named assistant when there are several,
else the first in key order), else null. Both resolve through resolveInstance,
need harness and model, and carry thinking when set. pack.state adds routeFrom,
and each hired or awaiting-owner receipt line carries it. Refusal next step,
CLI hint, WebUI hire reason and the bus, CLI and TOOLS docs say the refusal now
means neither has a route.
2026-11-14 18:32:01 -06:00
jason.woltje 3e53af3941 fix(bus,webui): pd review round, supersede after apply, one pack hire loop per org, hireError, fromPack (#1873, lane pd)
Review pd-review.md (changes 6). Fixed:
- P2#2: the owner's pack hire withdraws a pack-raised inbox decision only
  after its replacement hire applied; a replacement that refuses (route
  missing, prepare refusal) leaves the old decision open in the inbox.
- P3#3: an apply whose hire loop throws after the apply committed still
  answers the apply receipt, with no hires and the code as hireError; the
  route passes a code through and the card says the hires did not run.
- P3#5: the packs read marks an awaiting-owner line this pack's own hire
  raised fromPack: true; the owner's card counts it in "Hire the N".
- P3#6: one pack hire loop per business; a second refuses
  organization-busy and raises nothing.
- P2#1 docs: TOOLS.md and the bus README say no member surface calls
  pack.hire.console yet (the member surface is a recorded follow-up).

Deferred: P3#4 project agents naming their pack (projectUnion is shared
with the runtime).
2026-11-14 16:09:46 -06:00
jason.woltje 359b3299b4 feat(bus,cli,organization,webui): applying a starter pack is the hire decision (#1873, lane pd)
Ruling 2026-11-14: a person's pack apply records one hire decision per
proposed hire and applies it in the same act, through the hire-decisions
path, with the evidence an inbox approval leaves.

- bus: pack.apply.console runs the pack hire loop; pack.hire.console hires
  an applied record's open proposals. The owner's apply approves flagged and
  credential lines; a member with org.hire gets the unflagged hires and the
  rest open as awaiting-owner decisions; an agent apply still refuses
  human-required. Project packs hire into projects.<p>.agents. Nothing is
  hired twice. Credential lines are approved, not bound. New refusal codes
  pack-not-applied and pack-hire-route-missing. The instances read names the
  pack each hire came from; the packs read lists hired agents and open
  proposals with reasons.
- organization: pack.hire.console maps to org.hire; instances carry
  hireDecision.
- cli: mosaic org pack hire ID PACK [--project P]; apply prints the hires.
- webui: pack card shows N agents hired, open proposals with reasons and
  "Hire the N proposed agents"; Agents and organization pages redraw on
  mosaic-org-changed; agent cards say "from pack X"; Fire (not on the chief
  or assistant) removes the card at once with a receipt.
- docs: design doc section 3 dated note, TOOLS.md, package READMEs.
2026-11-14 15:40:10 -06:00
jason.woltje 65f7288cea fix(webui): template save maps the new template-exists refusal to 409, not outcome-unknown (#1873)
f6c added template-exists for a save under a taken name. The template
route had no entry for it, so a duplicate save answered 503
outcome-unknown. Map it to 409 and move the SP8 pin.
2026-11-13 20:14:49 -06:00
jason.woltje 211b32ef1a fix(cli): f6c re-check, a failed released-marker write still removes the start lock; docs name the new warning and code (#1873) 2026-11-13 20:14:21 -06:00
jason.woltje 163972e08e fix(cli): f6c review round, released start locks, ENOENT and path cut (#1873)
P3-1: releasing a console start lock marks it released through its own
descriptor and removes the path only while it is still that file; a
released lock put back by a racing clear is cleared by the next start or
stop.
P3-2: org definitions reports unknown-organization only when the
organization file itself is missing; another missing file names the
operation.
P3-3: the path cut also covers a path after ':' or inside backticks.
2026-11-13 20:14:21 -06:00
jason.woltje 23e504f331 fix(cli,bus,organization): E2E6 lane f6c, refusal lines name the next step (#1873)
1. Stale bus host lock refusals from bus status, start, stop and restart
   name mosaic bus recover ORG.
2. org definitions: unknown org, unknown or malformed name and bad id give
   one refusal or usage line, no stack trace, no host path.
3. Pack, board and workflow refusals print their hint as template save does;
   tested with the real CliError transport shape.
4. console start and stop clear a console/start.lock whose named supervisor
   (pid and start time) is gone; a live or unnamed holder refuses.
5. Template save keeps free text verbatim and writes no placeholders; the
   preview lists each field that mentions an org-specific name.
6. A request the shim never sent (no socket, connect refused) exits 5 and
   the CLI reports bus-not-running with the start and recover line.
7. autonomy-precondition carries the check that failed, including on the
   hire paths.
8. Saving under an existing template name refuses template-exists with a
   next step; refusal table entry added, channel-proof pins moved.
2026-11-13 20:14:21 -06:00
179 changed files with 22845 additions and 2156 deletions

No files matched your search

+6
View File
@@ -6347,3 +6347,9 @@ R5 quote fallback room (#797 D3, 2026-11-06, MVP3 lead): r4 review P2 found that
2026-11-09 UTC, PRD 1.20 and defect l (#1873, #1886; PRs #1887 03fe321b1 and #1888 7a97cfc4f). PRD 1.20: Jason approved draft 2 at 22:57Z ("The file looks fine other than that"; the Montage module name stays deferred). The PRD now has 118 requirements, with REQ-WS-1..8, REQ-AGENT-1..3, REQ-SYS-1..2, REQ-ACCT-1..2 and REQ-SETUP-1..2 added and REQ-ASSIST-1, REQ-USER-1, REQ-TASK-1 and REQ-WEB-3 amended. Builder Codex Terra xhigh declined to commit because stack-copy failed 20/1 (node-gyp missing from the test Node's npm); that failure is pre-existing on 483eccb3d, so the lead committed. Sol review APPROVE 0 (word-for-word diff against draft 2, catalog order, both requirements tests). Defect l: before, an agent that declared a store credential made the next bus start refuse, because Credentials refuses a missing store root and only issue() created it. After: start creates the root 0700 when any reference names the store; a root that exists with loose modes or as a symlink still refuses. Two new credential-verbs tests fail on the parent. Bus suite 171 files one at a time, 1713/0 (Node 26.12.1, env -i). Sol review APPROVE 0. uiorg redeployed at 7a97cfc4f, 23:15Z. Follow-up: the stack-copy node-gyp test environment. Reports: /mnt/storage/scratch/mosaic-lead/reports/{prd120-land,prd120-review,defectl-review}.md.
2026-11-10 UTC, unified workspace U1 and SYS1 (#1873; PRs #1889 d35447005 and #1890 2c6556ab1). U1, before: each org page read only its own bus and nothing read every org at once. After: /api/workspace returns projects, sessions, inbox, tasks and metrics from every org the owner holds, each row tagged with its org and each org with a state (ok, starting, down, timeout, invalid); `mosaic console restart` and `mosaic org reload <org>` send the F3 routes. Sol review CHANGES 0/2 on 2109458b3: malformed data from one org turned the whole read into a 503, and the per-org deadline left sockets and transport children running. Terra fix 0672d5fe8 validates each org's result inside its boundary and carries an absolute deadline and AbortSignal through the status check and transport; the new workspace-failures test is 0/10 on the parent and 10/0 on the fix. The lead re-pinned the webui bus.mjs hash in bus channel-proof (the deliberate signal/deadline change; nonces, argv and limits unchanged) and amended as d35447005. SYS1, before: no system-type kind. After: a system-type plug-in kind with five modules (business-management, coding, creative-writing, marketing, montage), an org enable list under plugins.system-type, owner-only project selection with an append-only project_system_types table (migration 3t-3u) and CLI verbs; the modules grant no tools yet (REQ-SYS-2 deferred). Sol review CHANGES 1/2 on a9629f332: the restore guard did not count project_system_types, the CLI channel did not admit the two project verbs, and the #811 migration-reader pin still expected 18 steps. Lead fix 2c6556ab1 (rebased on d35447005) adds the table to COUNTED and LISTED with refusal and in-run recount tests, admits both verbs with a run()-level channel test (red on the unfixed channel), and moves the pin to 19 steps ending 3t-3u; fix files 323/0 and rebase overlap files 63/0 (Node 26.12.1, one file at a time, env -i). Full gate on a9629f332 4040/5: the two stack-release pins above, and tester-reads 3/3, which also fails on 1616d1dd6 (project.mjs:95 refuses an org --tester init; follow-up). Correction to the uiorg deploy at 00:50Z: the deploy script switched the tree without the offline schema migration, so all five buses refused to start (normal startup refuses an older schema by design). The lead ran migrate-schema.mjs for the five org stores (3t to 3u, all ready), restarted the buses (201 each) and added the migration to the deploy script with stop-on-refusal. test3 refused writer-locked and stays down, as before. Reports: /mnt/storage/scratch/mosaic-lead/reports/{u1-review,u1-fix,org-sys1-build,sys1-review}.md.
2026-11-13 UTC, starter packs replace system types (#1873; PRs #1949 c0a60ed3a, #1950 1e65ff3f8, #1951 755ba3fa8, #1952 1ced0e392, #1953 dfef78834, #1955 9a649abf8, #1956 991eb8c33, #1957 34dd33101, #1959 0251acdad and #1960 e6ab8bc1f; final e6ab8bc1f). Backfilled 2026-11-16 by lane docs-1116 from uidev/LEAD-1110.md and git; the Lead wrote no entry at the time. Before: SYS1 (PR #1890, 2c6556ab1) made system types a plug-in kind with five modules, an org enable list under plugins.system-type and an append-only project_system_types table (migration 3t-3u); the modules granted no tools. After: the design docs/plans/2026-11-12_starter-packs-design.md landed as PR #1949 (doc only) after three fix rounds; Jason's FULL SEND at 21:06Z on 11-12 answered Q1 to Q3: system-type removed outright with no legacy, SP10 dropped, SP9 deletes the kind and drops project_system_types. Slices in landing order: SP3 the org keys packs, board and workflows and the applyPack writer op; SP1 the starter-pack plug-in kind and its checker; SP7 workflow guidance in the harness prompt; SP2 the five shipped packs; SP4 pack, board and workflow verbs, routes and CLI words; SP6 board labels, pack picker and workflow editor on the WebUI organization page; SP5 the chief applies a pack's non-definition half and raises hires from its proposals; SP8 the owner saves an organization's shape as a template; SP9 system types removed outright and bus schema 3v-3w dropping project_system_types. Test counts, Lead check then lane gate: SP3 98 files 1294/0, 1828/1; SP1 51 files 708/0, 2854/1; SP7 1281/0, 2537/1; SP2 150/0, 1556/1 at 18add86cb before its rebase onto SP7; SP4 4848/2, 6049/1; SP6 371 files 4233/1, 8262/23; SP5 229 files 2721/0, 8061/2; SP8 415 files 4650/1, 8125/2; SP9 497 files 5542/1, 8655/28. Each single Lead check red is CHAT-01 (host Python lacks jsonschema), red on base too; SP4's second red was the fixture federation-host.mjs wrongly in the run list, and Lead check lists are filtered to *.test.mjs since. The lane gate reds the log names are base or environment reds: CHAT-01, 19 agents/*/work probes, budget-supervisor 3v, ui-browser SSO, six v1 .woodpecker files and one claude-session timing test. Every slice was deployed to uiorg 7350 and verified; at e6ab8bc1f (03:46Z on 11-13) the offline 3v-3w migration ran on all five live stores, 5 stop 200, 5 bus schema 3w ready, 5 setup 201, the system-types route and its js returned 404, and no org file named system-type, so no wipe was needed. Corrections: the Lead's 21:38Z carry that SP2 pack steps must drop id was reversed at 21:46Z: pack steps keep id (SP1 checker) and SP4 drops id when it copies a step into the org file. The Lead's SP7 brief misstated the workflow shape; the lane built to the SP3 loader, which was correct. SP5's last commit before landing changed the broker canonical string builder after its re-check with no suite test; the Lead compared it with organization canonicalJson (7/7 same) and accepted it, and the integer-key pin test is deferred. SP9's first gate, before its rebase, ran packages/cli/live/ui-browser.test.mjs, which binds its own fixture on 17443, a lane rule breach; nothing was listening before or after, and the file was left out of later gates. The 'bus recover' deploy step refuses rc=3 in the agent shell on every deploy since D1; it is harmless while bus stop succeeds. Reports: /mnt/storage/scratch/mosaic-lead/reports/{starter-pack-design-build,starter-pack-design-recheck2,sp1-build-1112-starter-packs,sp2-build-1112-starter-packs,sp3-build-1112-starter-packs,sp4-build,sp5-build,sp6-build,sp7-build,sp8-build,sp9-build,sp9-rebase-recheck}.md.
2026-11-15 UTC, applying a starter pack is the hire decision, with the route fallback (#1873; PR #1963, b913f0f4c; commits 359b3299b and 3e53af394 lane pd, bfd2cc5e7 and b913f0f4c lane pr2). Backfilled 2026-11-16 by lane docs-1116 from uidev/LEAD-1110.md and git. Before: section 3 of the starter packs design said apply never hires; a person's apply left the pack's hires as proposals for the chief to raise or for a person with org.hire to start. On 7350 at 65f7288ce Jason applied packs and saw no agents. His ruling at 20:48Z on 11-14, verbatim: "Damnit. If I choose a starter pack and apply it, that is a decision!" After, lane pd: a person's apply (pack.apply.console from the WebUI, pack.apply from the CLI) raises one hire decision per proposal after the pack's commit and resolves it, with the evidence an inbox approval leaves. The owner's apply approves flagged and credential lines; a member with org.hire hires only proposals with neither, and the rest wait for the owner as awaiting-owner. An agent apply hires nothing. Hires are written with no credential material, so services show unbound until someone binds them. The design's section 3 carries a 2026-11-14 change note. Route fallback: at 22:03Z the Lead found every 7350 chief had model null, so pack hires would refuse pack-hire-route-missing on Jason's orgs. Ruling at 22:13Z: the hire route is the chief's, else the org assistant's harness and model, else refuse; lane pr2 stacked on pd. Tests: pd gate 3957/0 at its first commit, review changes 6 (2 P2) fixed or deferred, re-check APPROVE; Lead check of pd with pr2 333 files 3813/1, the red a control-board scan.test mtime-tie flake in a file neither lane touched, 70/0 three times alone. Lead ruling on the re-check's P2 1: a member pack hire surface is a follow-up row, because a new transport for a member hire cap is a security boundary and the owner path covers apply; Jason said "proceed". Deployed b913f0f4c at 01:03Z on 11-15: stop 5, schema 3w 5, setup 5. The Lead ran pack hire on faceless (montage ideas-1 and research-1, coding pm-1, coder-1 and reviewer-1, all on fixture-deterministic) and acme (business-management pm-1 and research-1 on opus), each with routeFrom assistant. Related fix the same night: Jason reported "adapter exited 127" in Messages. Lane r127 found the Lead's deploy-uiorg.sh (a scratch script, not in the repository) started the Console without MOSAIC_CLAUDE_BIN, so claude-code sessions ran the /usr/bin/claude wrapper whose target under /opt the sandbox does not bind. The Lead patched the script and landed PR #1964 387f73a7a, which makes exit 127 name the missing program; Lead check 16 files 285/0. Both assistant kinds replied on 7350 at 387f73a7a by 03:33Z. Reports: /mnt/storage/scratch/mosaic-lead/reports/{pd-build,pd-review,pd-recheck,pr2-build,pr2-review,r127-build,r127-review,r127-recheck}.md.
2026-11-15 UTC, single pane slices sp1 to sp14 (#1873; PRs #1965 to #1978; final c26879637). Backfilled 2026-11-16 by lane docs-1116 from uidev/LEAD-1110.md and git. Before: a Side by side page sat in the sidebar beside the organization pages, and Jason's walkthrough on 65f7288ce (20:48Z on 11-14) found agents from an applied pack not visible. His direction: #/dashboard system-wide, no organization URL base, side-by-side Assistant threads in place of Side by side, and the 3-click rule. The Lead ruled at 03:33Z on 11-15 that #/orgs/<id>/... stays the address of an org page but is a route inside one global shell, with no reload and no mode switch. After, slice by slice (PR, tip, Lead check, lane gate): sp1 shell, #/dashboard system page, org drill-in without reload, a down org says so (#1965, c7aecbffa, 128/0, 1031/0, two reviews, nine findings fixed); sp2 dashboard polish, bare org route, theme, one down banner (#1966, d1b01329b, 132/0); sp3 system Inbox (#1967, 3885f4628, 111/0, 892/0; a theme fix and a render-order fix were read by the Lead, not a reviewer); sp5 system Agents, landed before sp4 (#1968, f97e0d3ae, 89/0 plus unified-workspace 18/0, 745/0); sp4 system Tasks, which the Lead rebased onto f97e0d3ae with three one-line union conflicts (#1969, ed4f45ed2, 131/0, 937/0 before the rebase); sp6 system Assistant with up to three threads from any org side by side, the open set in the hash, Side by side removed from the sidebar and #/side-by-side landing on Assistant (#1970, 789e2bcdd, 95/0, 1472/0, four review rounds); sp7 seven small fixes (#1971, a9912983e, 141/0, 1483/0, three review rounds); sp8 KPI tiles from real reads only and the 3-clicks table (#1972, c66f1ec00, 119/0 plus org-live-edit-browser 4/0 alone, 1490/2 with two load flakes that each passed alone twice, three small fixes not re-reviewed); sp9 read-only workflow list and graph per org (#1973, 7c6571768, 143/0, 1504/0); sp10 workflow edit in the graph (#1974, bd29e756a, 146/0, 1515/0); sp11 eight fixes including agent counts that disagreed and Done this week (#1975, 5b6b39f08, 164/0, 1527/0, three review rounds); sp12 agent drawer from #/agents and org session rows (#1976, 69ce460f9, 196/0, 191 files 1538/0); sp13 organization page fits its width, #/orgs/<id>?query parses, drawer state pending until the instances read answers (#1977, 68df55130, 205/0, 192 files 1547/0); sp14 Queue card off the organization page, running not read where an answer carries no runs, kept Assistant pane messages keyed by an opaque viewer, drawer repaint without new page reads (#1978, commits 2fc97a3ed and c26879637, 218/0, 192 files 1549/0, review changes 1 with the P2 fixed, re-check approve). sp14 adds `viewer` to /api/config (32 hex of sha256 over provider, iss and sub; `local` without sign-in) and adds no route. The Lead ruled at landing of sp13 that the Queue card leaves the organization page; #/queue stays. State at c26879637: system pages #/dashboard, #/inbox, #/agents, #/tasks and #/assistant; org pages at #/orgs/<id>/... inside the same shell. Each slice was deployed to uiorg 7350 with five buses up (deploy log per tip under reports/deploy-<sha>.log); sp1 and sp8 to sp14 record 5 stop, 5 schema 3w and 5 setup. An acme assistant reply was checked live after sp1 and sp6 to sp14; after sp4, #/agents showed the acme assistant running mid-reply; the log records no reply check for sp2, sp3 and sp5. Corrections: sp15 was launched at 19:23Z on a wrong premise. The Lead had told Jason, from reading code only, that the broker's async instances path was the real cause of the sp12 drawer saying not running. The lane stopped at BASE with no diff: the shipped runtime answers instances synchronously (runtime.mjs:1263), and a probe on a real startBroker showed the running and alive arrays present. The sp12 live shot had a 9000 ms screenshot budget that caught the paint before the read; the sp13 shot at 30000 ms shows State running. sp15 closed at 19:26Z with no change and no bus row; sp14's running not read item now only guards a failed or odd read. The Lead's lesson: prove a fault live before naming it a cause. The sp14 live shots read 0 running because they were taken right after the bus restart, before any session started. Follow-ups after sp14: empty space under Active agent sessions at 1440, a drawer pending gap, viewer read once per tab with an unsalted hash, the open pane set kept per browser, and the Dashboard org table scrolling sideways at 390. Reports: /mnt/storage/scratch/mosaic-lead/reports/{sp1-build,sp2-build,sp3-build,sp4tasks-build,sp5agents-build,sp6threads-build,sp7polish-build,sp8kpis-build,sp9workflows-build,sp10workflowedit-build,sp11fixes-build,sp12agentdrawer-build,sp13orgpagefit-build,sp14orgpagetruth-build,sp15businstancesruns-build}.md.
+6
View File
@@ -2124,3 +2124,9 @@ are never rewritten or removed; corrections are new entries.
2026-11-09 UTC | Mos (lead, Claude Opus 5.5) | Organizations F3 fix round and landing (#1873) | PR #1884 merged a8f9f0957; review P3 fixed, P1 README corrected with follow-up #1883; 195/0 focused suite; uiorg redeployed 22:45Z.
2026-11-09 UTC | Mos (lead, Claude Opus 5.5) | PRD 1.20 landing and defect l (#1873, #1886) | PR #1887 merged 03fe321b1, PR #1888 merged 7a97cfc4f; both Sol reviews APPROVE 0; bus suite 1713/0; uiorg redeployed 23:15Z; U1, U2 and U4a builds dispatched.
2026-11-10 UTC | Mos (lead, Claude Opus 5.5) | U1 and SYS1 landings (#1873) | PR #1889 merged d35447005, PR #1890 merged 2c6556ab1; both Sol reviews CHANGES, fixed (U1 by Terra, SYS1 by the lead); uiorg at 2c6556ab1 after the missed 3t-3u store migration was run; deploy script now migrates.
2026-11-10 UTC | Sage (Lead) | redact3 landing (#1873) | PR #1912 merged 96c900d21 at 23:56Z, gate 268 files 3412/0, Opus review changes 2 fixed; uiorg deploy started. Backfilled 2026-11-16 by lane docs-1116 from uidev/LEAD-1110.md and git.
2026-11-11 UTC | Sage (Lead) | Organizations, redaction, accounts, dev readiness and credential binding landings (#1873) | PRs #1913 to #1944 merged, a4eed1e21 to 6d0e9f89b: A2, golden1, TI, redact4, A3, M3 with M3-recon, acct-anchor, org-names, polish2, run sheet doc, cred-bind design, PL1, base-reds, redact5, T1, timing2, cleanup-time, A4, supcost, defscan, redact6, AU, D4, D3, harness-scan, D2, D1, CB01, bus-stop, agent-guard, proxy-ui, CB2. Jason approved CB0 to CB5 at 17:55Z. Per-landing check counts are in uidev/LEAD-1110.md. Backfilled 2026-11-16 by lane docs-1116.
2026-11-12 UTC | Sage (Lead) | E1, E2, CB3, E3, CB4 and starter packs design, SP3, SP1, SP7, SP2, SP4 landings (#1873) | PRs #1945 8827905ba (E1), #1946 666f4d686 (E2), #1947 0b8fe202b (CB3), #1948 2ad4b30eb (E3), #1949 c0a60ed3a (design), #1950 1e65ff3f8 (SP3), #1951 755ba3fa8 (SP1), #1952 1ced0e392 (SP7), #1953 dfef78834 (SP2), #1954 95c2ce143 (CB4), #1955 9a649abf8 (SP4). Jason's FULL SEND on starter packs at 21:06Z: system types removed outright, SP10 dropped. The log first dated the E1 landing 11-11; its own correction and git put it at 02:48Z on 11-12. Backfilled 2026-11-16 by lane docs-1116.
2026-11-13 UTC | Sage (Lead) | Starter packs SP6, SP5, SP8, SP9 and CB5 landings; E2E round 6 started (#1873) | PRs #1956 991eb8c33 (SP6), #1957 34dd33101 (SP5), #1958 a9d72b3cd (CB5, credential binding CB0 to CB5 complete), #1959 0251acdad (SP8), #1960 e6ab8bc1f (SP9). uiorg 7350 at e6ab8bc1f: bus schema 3w on all five stores, system-types route 404. E2E R6 CLI and WebUI lanes started 23:59Z. Backfilled 2026-11-16 by lane docs-1116.
2026-11-14 UTC | Sage (Lead) | E2E round 6 fixes and the pack apply ruling (#1873) | E2E R6 CLI 0/0/7, WebUI 0/3/15. PR #1961 23b5e24eb (f6w) and PR #1962 65f7288ce (f6c) merged; uiorg verified at 65f7288ce 02:40Z. Jason's walkthrough at 20:48Z: applying a starter pack is a decision, plus the single pane direction. Route fallback ruled 22:13Z. Backfilled 2026-11-16 by lane docs-1116.
2026-11-15 UTC | Sage (Lead) | Pack decision, exit 127 fix and single pane slices sp1 to sp14 (#1873) | PR #1963 b913f0f4c (pd with pr2), PR #1964 387f73a7a (r127), PRs #1965 to #1978 (sp1 to sp14), final c26879637 at 20:19Z; each deployed to uiorg 7350. sp15 launched 19:23Z on a wrong premise (a bus instances fault that did not exist) and closed 19:26Z with no change. Backfilled 2026-11-16 by lane docs-1116.
+4
View File
@@ -346,8 +346,12 @@ For local development on a named instance only, `mosaic bus start BUSINESS --dev
The hire form and the autonomy panel from a terminal (E2, #1873, P1-3). `mosaic org role-templates|hire|fire|change ORG` and `mosaic org autonomy ORG [set|review]` send the page's own request to the running Console's org route (`/api/orgs/ORG/decisions/hire/templates|start`, `/api/orgs/ORG/autonomy[/review]`), as `org reload` does, so the Console applies the same owner, `--send`, origin, body and live-session checks and the same bus verbs run (`hire.templates.console`, `hire.start.console`, `autonomy.get.console`, `autonomy.set.console`, `autonomy.review.console`). `hire` and `change` read the templates first and send the chosen template's name and sha256, as the form does. `autonomy set` needs the 64-hex `--revision` from `mosaic org autonomy ORG` and sends every setting the panel sends, with only the named ones changed; a stale revision is refused `revision-conflict`; an empty `--authority-resolver ""` clears the resolver, as emptying the panel's field does. These verbs need a named instance (`MOSAIC_CONFIG` set to `~/.config/mosaic-NAME/config.json`) whose Console runs with `--dev-local-owner`; the default instance is refused with exit 3. A Console refusal exits 3 with the Console's code and message; `outcome-unknown` exits 1; an unknown template exits 2. Every one of these verbs, reads included, refuses inside an agent run. `mosaic tasks create|edit|archive` are the task board's three writes: the arguments pass the board's own check (`workspace-tasks.mjs parseTaskWrite`) and go to the bus as the person (`tasks.create|edit|archive`, human transport), so the bus runs its human, field, digest and archive checks. A stale `--expect` is refused `task-conflict`; read the digest with `mosaic tasks --json`.
Starter packs (#1873): `mosaic org pack list`, `mosaic org pack preview ID PACK [--project P]`, `mosaic org pack apply ID PACK --digest D [--project P]` and `mosaic org pack hire ID PACK [--project P]` call the bus as the organization's human (`packs`, `pack.preview`, `pack.apply`, `pack.hire`). Ruling 2026-11-14 ("If I choose a starter pack and apply it, that is a decision!"): a person's apply is the hire decision. After the pack commits, the same act hires each proposed agent through the hire-decisions path and the receipt's `hires` lists `{name, state, decision | code}` per proposal (`hired`, `exists`, `open`, `awaiting-owner`, `refused`); a `hired` or `awaiting-owner` line adds `routeFrom: 'chief' | 'assistant'`. The owner's apply approves the flagged and credential lines; a credential line is approved but not bound, so the agent's launch refuses `credential-unbound` until its services are bound. The bus verb `pack.hire.console` also takes a member's console cap with `org.hire`: it hires only the proposals with no flagged or credential line, and the rest wait for the owner in the inbox. No member surface calls it yet: the WebUI packs routes and the CLI `pack` words are the owner's. An owner's pack hire also replaces and approves a hire this pack's own member hire left in the inbox; the old decision is withdrawn only after the new hire applies. Two pack hires on one organization at once: the second refuses `organization-busy`; an apply whose hire loop did not run still answers the apply's receipt with `hireError` and no hires. An agent's apply hires nothing. `pack hire` reruns the loop on a pack already applied and hires none twice; it refuses `pack-not-applied` when the pack has no packs entry, and a hire runs as the chief of staff's harness and model, else the organization assistant's (the instance whose definition is `assistant`), and a proposal refuses `pack-hire-route-missing` only when neither has both. All pack words refuse inside an agent run (exit 3). The WebUI pack card's "Hire the N proposed agents" is `POST /api/orgs/<id>/packs/hire`. Details: `packages/cli/README.md`, `packages/bus/README.md` and `packages/webui/README.md`, "Starter pack hires"; design: `docs/plans/2026-11-12_starter-packs-design.md` section 3.
The bus and Console lifecycle verbs refuse inside an agent run (agent-guard, #1873): `mosaic bus start`, `bus stop`, `bus restart` and `bus recover`, and `mosaic console start`, `console stop` and `console restart`, and `mosaic org archive` and `org delete`, which stop the organization's bus, and `mosaic org restore`, which starts it (`org restore --no-bus` starts nothing and is not refused), and `mosaic org role-templates`, `hire`, `fire`, `change` and `autonomy` (E2). Each exits 3 with `refused: this runs only from a human shell, outside any agent run (found MARKER in the environment)` before it reads anything. It checks the environment it is given and its own process environment, so a sanitized environment does not hide a marker. A usage error (a missing or extra argument, `--pm` with `--no-launch`, or a bad `--dev-insecure-bind`/`--dev-allow-host`) still comes first (exit 4). `mosaic bus status` and `mosaic console status` stay open to agents. The Console's Restart bus and Restart Console controls keep working: the Console starts its bus host with its own environment, which carries no marker, and Restart Console relaunches the Console under its supervisor without going through the CLI. The markers are the ones `packages/cli/src/transport.mjs` lists. The check is cooperative: a process that drops the markers from its environment is not stopped by it.
Refusal lines (E2E6, #1873). A refusal that has a next step prints it on a second line, `mosaic: next: ...`, after the unchanged message, so callers that match the message keep working. `mosaic bus status`, `start`, `stop` and `restart` on a stale bus host lock exit 3 with `mosaic: stale bus host lock ...` and `mosaic: next: if the bus host died, clear it with mosaic bus recover ORG; recover refuses while the host still runs`. A human-transport verb whose bus is not running (no socket, or the connect refused before anything was sent) exits 3 with `bus-not-running: the bus for ORG is not running, so the request was not sent` and a next line naming `mosaic bus start ORG` and `mosaic bus recover ORG`; `outcome-unknown` (exit 1) stays for a request that left and got no answer. `mosaic org definitions` with an unknown organization, an unknown or malformed name, or a bad id prints one refusal line (exit 3; `unknown-organization` only when the organization file itself is missing, `definitions-unreadable` when `templates` cannot read the roles directory) or, for a bad id, the usage (exit 4), with no stack trace and no host path. Pack, board and workflow refusals carry their next step as `template save` does. `mosaic console start` and `console stop` clear a `console/start.lock` whose named supervisor (pid and start time) is gone, once, with a `cleared a console start lock left by process PID, which is gone` warning; a lock whose holder still runs, or that names no holder, refuses and stays. A start or stop releasing its lock marks it released through its own descriptor and removes the path only while it is still that file, so a lock put back after its release is cleared the same way, with a `cleared a console start lock its holder had released` warning. An `autonomy-precondition` refusal from the bus carries the check that failed (owner notices off, no tested reverse, a resolver without the right, no `review.verdict` holder, no enforced budget, out of the loop only from near the loop, the trail review or near-loop decision missing); the human-transport child writes only the code, so a terminal `org autonomy set` shows the Console's message. `mosaic org template save` writes free text verbatim: it never rewrites prose, and the preview lists every field that mentions the organization id, a project id, an agent name or the owner's account, with the names it mentions, for the owner to edit before sharing. Saving under a name already saved for the account refuses `template-exists` (exit 2, nothing written) with a next line to save under another name or list the saved ones with `mosaic org template list ORG`.
The instance processing switch is separate from per-business launches off/on.
`mosaic halt` durably stops managed processing across every business in the
selected configuration's data root. The bus stays up for reads and human
@@ -374,6 +374,48 @@ exactly as if a person had made them by hand. The steps:
`projects.<p>.agents`; those entries refuse instance credential material
(`BOUND_KEYS`, `agent-levels.mjs:21`).
**2026-11-14 change (#1873, lane pd).** Jason's ruling: "Damnit. If I
choose a starter pack and apply it, that is a decision!" This replaces
"Apply never hires" above for a person's apply. The `packs` entry and the
proposals stay as written; what changes is who acts on them:
- A person's apply (`pack.apply.console` from the WebUI, `pack.apply` from
the CLI) is the hire decision. In the same act, after the pack's commit,
the broker raises one hire decision per proposal through the
hire-decisions path and resolves it, leaving the evidence an inbox
approval leaves: the decision row, its resolved event, `human.input`,
`hire.consume`, the `hire.apply` event and `action.allowed pack.hire`.
The hired entry carries `hireDecision`.
- Invariant 7 still decides each line. The owner's apply approves the
flagged and credential lines. A member with `org.hire` hires only the
proposals with neither a flagged nor a credential line; each of the
others is raised as an open decision that waits for the owner in the
inbox (`awaiting-owner`). The owner's later pack hire withdraws such a
decision and hires the agent itself. An
agent apply hires nothing: the hire stays a proposal for the chief, and
a hire verb from an agent is refused `human-required`.
- Credentials take the smallest rule. The hire writes the entry with no
credential material, so its services show `unbound` and a launch is
refused `credential-unbound` until someone binds them. The owner's
approval covers the credential lines; it binds nothing and reads no
secret.
- The route is the chief of staff's resolved harness and model. With
none, that proposal is refused `pack-hire-route-missing` and stays open.
Note 2026-11-14 (lead ruling, lane pr2): the route is the chief's, else
the organization assistant's (the instance whose definition is
`assistant`; the one named `assistant` when there are several, else the
first in key order), and the refusal applies only when neither resolves
a harness and a model. Hire lines carry `routeFrom`.
- `pack.hire` / `pack.hire.console` (`mosaic org pack hire ID PACK
[--project P]`, `POST /api/orgs/<id>/packs/hire`) runs the same loop on
a pack already applied, refused `pack-not-applied` otherwise. A proposal
whose instance exists is `exists`, and one with an open decision is
`open` or `awaiting-owner`, so neither a re-apply nor `pack hire` ever
hires twice. A project pack hires into `projects.<p>.agents`.
- Each hire line in the receipt is `{name, state, decision | code}` with
state `hired`, `exists`, `open`, `awaiting-owner` or `refused`. The
packs read adds `hired` and `open` (with each proposal's reason) to each
applied entry, and the instances read names the pack an agent came from.
### The surface
| Layer | Name |
+1
View File
@@ -586,3 +586,4 @@ git history + Gitea issues.
- 2026-09-26 (sage, lead): Jason's ruling: Sage leads the project, Darkwing is a collaborating seat, more seats to follow, development stays in T3 for now. The fleet Sage seat that took Invoice Ninja coordination outside Jason's instructions is being decommissioned; moving work onto the new stack is the fix. Suites all green. Rows 24 and 25 pushed (1685deb4..43d7574d). Open: about 11 days of uncommitted agent work in the tree (row 16 launch files, row 22, #1512, WUI evidence), 23 untracked aws-* skill directories in skills/ from 2026-09-21, and Jason's target for the next phase.
- 2026-10-13 (sage, lead): Jason's PM re-test on 664199f7 is finished (Mos; PM run rcc0f72be8b17; Vikunja #228). Paging, the Board's held roles, the Messages page and the #229 loop (coder push 010d30cb, review, approve, PM close) all worked; #230 and #231 are done, #232 stays open for the secrets-path probe. Two faults checked and dropped: the reviewer did run the tests before its verdict, and the PM's clone did hold the row 95 Board code. Two filed: row 104 (#1598) seat git identity, row 105 (#1599) a review request says whether a reviewer is running. Rows 96, 101-105 briefed; row 85 released to build. Row 85's live steps, any bus restart and row 102's public/ change each need Mos's go. Row 100 waits on Jason (Vikunja #257). Formatting, Jason's direction: no formatting row now. Chat output will be formatted in the TUI and WebUI the way chat interfaces usually do it, made our own; T3 Code's chat is his example. Carry it into the TUI and WebUI chat work.
- 2026-11-15 (sage, lead; written 2026-11-16 by lane docs-1116 from uidev/LEAD-1110.md and git): single pane state at c26879637 (#1873, PRs #1965 to #1978). One WebUI shell. System pages #/dashboard, #/inbox, #/agents, #/tasks and #/assistant cover every organization; #/queue stays its own page. Organization pages are #/orgs/<id>/... routes inside the same shell, with no reload and no mode switch (Lead ruling 03:33Z 11-15). Side by side is gone from the sidebar; the Assistant page holds up to three threads from any organization side by side, and #/side-by-side lands there. The organization page has KPI tiles from real reads, a workflow list and graph with edit, an agent drawer (?agent=<org>:<name>), and no Queue card. Where an instances answer carries no runs the page says running was not read, never 0. /api/config names an opaque `viewer` that keys kept Assistant pane messages. Applying a starter pack is the hire decision (PR #1963 b913f0f4c). Follow-ups: empty space under Active agent sessions at 1440, a drawer pending gap, viewer read once per tab with an unsalted hash, the open pane set kept per browser, the Dashboard org table scrolling sideways at 390. Detail: BUILD-LOG.md 2026-11-15 entries.
+37
View File
@@ -1135,3 +1135,40 @@ Each write records `human.input`. A task read returns a `digest` that can be sup
`task-conflict`. Existing assignees may remain after a role is removed, but new assignees
must be current roles. Automatic tail placement and an explicitly occupied position refuse
`task-position-full` when there is no room; no task row is written.
## Starter pack hires (ruling 2026-11-14, #1873)
"If I choose a starter pack and apply it, that is a decision!" A person's
`pack.apply` (the organization's human, outside any run) or `pack.apply.console`
hires the proposals of the packs entry it wrote, once the apply has committed.
An agent's `pack.apply` hires nothing. `pack.hire` (the owner's human session)
and `pack.hire.console` (the owner's or a member's console cap, needing
`org.hire`) run the same loop on a pack already applied; with no packs entry they
refuse `pack-not-applied`.
Each proposal goes through `#raiseHire` and `hire.resolve.console`, the path an
inbox approval takes: the decision row, its resolved event, `human.input`,
`hire.consume`, the hire's commit and `hire.apply` event, plus
`action.allowed {operation: 'pack.hire', pack, version, origin, project, hire,
decision}`. The route is the chief of staff's resolved harness and model (the
`launch.by` instance), else the organization assistant's: the instance whose
definition is `assistant`, the one named `assistant` when there are several,
else the first in key order. Thinking is carried when set. With neither the
proposal refuses `pack-hire-route-missing`. A `hired` or `awaiting-owner` line
carries `routeFrom: 'chief' | 'assistant'`. The entry is written with
no credential material, so a credential line leaves its services `unbound`.
A proposal whose instance exists is `exists`; one an open hire decision names is
`open`, so nothing is hired twice. The owner approves every line, and replaces
an open decision an earlier hire of the same pack left for the owner: the new
hire is raised and applied first, and the old decision is withdrawn only once it
has applied, so a replacement that refuses leaves the old one in the inbox. A member's flagged or credentialed hires are raised after
the others, left open for the owner's inbox (`awaiting-owner`). A hire that
refuses records `action.allowed {operation: 'pack.hire.refused', code}` and the
loop goes on. The `packs` read adds `hired` and `open` to each applied entry,
and the `instances` read adds `pack: {id, origin, project}` to each instance a
pack hire created. An `awaiting-owner` line this pack's own hire raised carries
`fromPack: true` (the owner's pack hire would replace it). One pack hire loop
runs per business at a time; a second refuses `organization-busy`. An apply
whose hire loop throws after the apply committed still answers the apply's
receipt, with no hires and the loop's code as `hireError`. No member surface
calls `pack.hire.console` yet; the Console's packs routes are the owner's.
+253 -57
View File
@@ -11,7 +11,7 @@ import { initializeControl, processingStatus } from '../../processing-control/sr
import { NAME as HARNESS_NAME } from '../../plugins/src/kinds.mjs';
import { loadRequirements } from '../../tasks/src/requirements.mjs';
import { MERGE, LandingRefusal, readLanding } from './landing.mjs';
import { pluginName, ID_PATTERN, THREAD_DEFINITIONS, END_PROTECTED, forkProblem, forkUrl, credentialKind, validArgv, commandAllowed, HOST_ID, CREATIVE_DEFINITIONS, giteaName, parseGiteaUrl, covers, grantScopeOf, grantInScope } from '../../organization/src/vocabulary.mjs';
import { pluginName, ID_PATTERN, THREAD_DEFINITIONS, END_PROTECTED, forkProblem, forkUrl, credentialKind, validArgv, commandAllowed, HOST_ID, CREATIVE_DEFINITIONS, giteaName, parseGiteaUrl, covers, grantScopeOf, grantInScope, SYSTEM_ONLY_REFUSAL, systemOnly } from '../../organization/src/vocabulary.mjs';
// Kept closed while S1 lands; its vocabulary is the integration authority.
export const ACTIONS = Object.freeze([
@@ -178,7 +178,7 @@ export const USER_VERBS = Object.freeze(['project.list', 'thread.create', 'threa
'thread.share', 'thread.unshare', 'thread.shares']);
// Row 252 (#1753, design sections 2-3): the only verbs a Console owner cap reaches. Every other verb
// refuses it human-required before its own checks, and these refuse every other cap.
export const CONSOLE_VERBS = Object.freeze(['project.remote.get.console', 'project.remote.set.console', 'autonomy.get.console', 'autonomy.set.console', 'autonomy.review.console', 'decision.confirm.console', 'decision.reverse.console', 'request.workspace.console', 'request.artifact.console', 'decision.preview.console', 'decision.resolve.console', 'hire.preview.console', 'hire.resolve.console', 'hire.start.console', 'hire.templates.console', 'prd.revoke.console', 'request.mode.console', 'request.draft.console',
export const CONSOLE_VERBS = Object.freeze(['project.remote.get.console', 'project.remote.set.console', 'autonomy.get.console', 'autonomy.set.console', 'autonomy.review.console', 'decision.confirm.console', 'decision.reverse.console', 'request.workspace.console', 'request.artifact.console', 'decision.preview.console', 'decision.resolve.console', 'hire.preview.console', 'hire.resolve.console', 'hire.start.console', 'hire.templates.console', 'pack.hire.console', 'prd.revoke.console', 'request.mode.console', 'request.draft.console',
// Task 3 (#1839): and the owner's intake controls. The reads and writes are the same lifecycle methods the PM's
// unsuffixed verbs reach, with the owner's verified (provider, iss, sub) as the only caller; the PM-only
// request.question and the PM's own reads keep their unsuffixed names and refuse a console cap.
@@ -233,7 +233,7 @@ const TEMPLATE_KEYS = Object.freeze({
export const TEMPLATE_BUS_KEYS = Object.freeze(Object.fromEntries(Object.entries(TEMPLATE_KEYS).flatMap(([verb, k]) => [[verb, k], [`${verb}.console`, k]])));
// The codes a template refusal keeps, each with its reason: a field path or a checked name, never a
// value from the organization file and never a host path.
const TEMPLATE_CODES = Object.freeze(['template-secret-suspected', 'invalid-request', 'human-required', 'not-configured', 'pack-plan-stale', 'starter-pack-invalid', 'starter-pack-template-changed']);
const TEMPLATE_CODES = Object.freeze(['template-secret-suspected', 'template-exists', 'invalid-request', 'human-required', 'not-configured', 'pack-plan-stale', 'starter-pack-invalid', 'starter-pack-template-changed']);
// Row 175: the organization verbs a tester may call. Its writes run every check the human's do
// and log actor `tester`; row 176 adds routes reads; limits.set, organization.set and organization.revision refuse it.
export const TESTER_ORGANIZATION_VERBS = Object.freeze(['limits', 'plugins', 'instances', 'plugins.set', 'instances.set', 'routes.set', 'routes']);
@@ -280,6 +280,11 @@ const canonical = (x) =>
typeof x === 'string' && /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(x) &&
Number.isFinite(Date.parse(x)) &&
new Date(x).toISOString() === x;
// proxy-pickup (#1873): the one plain line a bus without a proxy client gives for not-configured.
// The runtime writes it from static text and a refusal code; only that line passes, and never
// into refusal evidence.
const proxyCause = error => error instanceof BusError && error.code === 'not-configured' && typeof error.reason === 'string' && error.reason.length <= 300 ? error.reason : undefined;
export class BusError extends Error {
// Guidance is static policy text; never quote arguments or file bytes here.
constructor(code, reason) {
@@ -289,9 +294,12 @@ export class BusError extends Error {
if (reason !== undefined) this.reason = reason;
}
}
const fail = (code) => {
throw new BusError(code);
// E2E6 fix 7: a refusal may carry a reason, static text that names which check failed; it never
// quotes an argument or file bytes.
const fail = (code, reason) => {
throw new BusError(code, reason);
};
const BUDGET_UNCOVERED = 'no enforced budget covers new agents; authority away from the loop needs one';
const object = (x) => x !== null && typeof x === 'object' && !Array.isArray(x);
// #1873 CB5: a copy binding proposal leaves the bus only as its copy and its change. The copy id,
// incarnation, definition pin, services, grant ids and slots stay in the raise event, which the
@@ -636,6 +644,9 @@ export class Broker {
#builtinBinding;
#organization;
#hires;
// Businesses with a pack hire loop running: a second loop on the same business refuses
// organization-busy rather than raising a second decision for the same agent.
#packHiring = new Set();
#autonomyHost;
#pluginService;
#credentialVerbs;
@@ -6083,7 +6094,7 @@ export class Broker {
const args = request.args ?? {};
if (!object(args)) fail('invalid-request');
return Promise.resolve().then(() => this.#proxyPage(request.verb, args, { business: s.business, human: s.human }))
.catch(error => { throw this.#refused(s, new BusError(PROXY_PAGE_CODES.includes(error.code) ? error.code : 'proxy-down'), { verb: request.verb }); });
.catch(error => { throw this.#refused(s, new BusError(PROXY_PAGE_CODES.includes(error.code) ? error.code : 'proxy-down', proxyCause(error)), { verb: request.verb }); });
}
// #1873: the fence clear takes restart evidence, which the runtime re-proves on the host
// before the lock clears. Owner only, before every other gate, like the proxy page verbs.
@@ -6262,16 +6273,16 @@ export class Broker {
if (CREDENTIAL_VERBS.includes(request.verb)) return this.#requestCredential(s, request.verb, structuredClone(args));
if(['autonomy.get.console','autonomy.set.console','autonomy.review.console','decision.reverse.console'].includes(request.verb)) {
this.#autonomyOwner(s);
return this.#autonomyConsole(s,request.verb,structuredClone(args)).catch(e=>{throw this.#refused(s,e instanceof BusError?e:new BusError(e.code??'outcome-unknown'),request);});
return this.#autonomyConsole(s,request.verb,structuredClone(args)).catch(e=>{throw this.#refused(s,e instanceof BusError?e:new BusError(e.code??'outcome-unknown',e instanceof BusError?e.reason:undefined),request);});
}
if (s.hireMembership && !['hire.preview.console','hire.resolve.console','hire.start.console','hire.templates.console'].includes(request.verb)) fail('human-required');
if (s.hireMembership && !['hire.preview.console','hire.resolve.console','hire.start.console','hire.templates.console','pack.hire.console'].includes(request.verb)) fail('human-required');
if(request.verb==='decision.resolve' && !s.human) {
if(s.tester)fail('tester-refused');
keys(args,['id','choice','note'],['id','choice']);identifier(args.id);
}
if(request.verb==='decision.resolve' && !s.human && ['role.hire','role.fire','role.change'].includes(this.#decision(s,args.id).action)) {
const d=this.#decision(s,args.id);
if(d.route_to!=='human')return this.#resolveAuthority(s,args).catch(e=>{throw this.#refused(s,e instanceof BusError?e:new BusError(e.code??'outcome-unknown'),request);});
if(d.route_to!=='human')return this.#resolveAuthority(s,args).catch(e=>{throw this.#refused(s,e instanceof BusError?e:new BusError(e.code??'outcome-unknown',e instanceof BusError?e.reason:undefined),request);});
}
if(request.verb==='hire.templates.console') {
keys(args,[]);const caller=this.#hireCaller(s);
@@ -6285,14 +6296,32 @@ export class Broker {
const input=request.verb==='decision.raise' ? (()=>{ keys(args,['action','hire'],['action','hire']); if(args.action!==`role.${args.hire?.op}`)fail('invalid-request'); return args.hire; })() : args;
// #1873 SP5: a raise from a pack's recorded proposal; the pin, not the caller, names the role.
if(request.verb==='hire.raise' && object(args) && Object.hasOwn(args,'proposal'))
return Promise.resolve().then(()=>this.#raiseHire(s,this.#proposalHire(s,args),false)).catch(e=>{throw this.#refused(s,new BusError(e.code??'invalid-request'),request);});
return this.#raiseHire(s,input,request.verb==='hire.start.console').catch(e=>{throw this.#refused(s,new BusError(e.code??'invalid-request'),request);});
return Promise.resolve().then(()=>{const r=this.#proposalHire(s,args);return this.#raiseHire(s,r.input,false,{pack:r.pack});}).catch(e=>{throw this.#refused(s,new BusError(e.code??'invalid-request',e instanceof BusError?e.reason:undefined),request);});
return this.#raiseHire(s,input,request.verb==='hire.start.console').catch(e=>{throw this.#refused(s,new BusError(e.code??'invalid-request',e instanceof BusError?e.reason:undefined),request);});
}
if(request.verb==='decision.preview.console' && ['role.hire','role.fire','role.change'].includes(this.#decision(s,args.id).action))return this.#hireConsole(s,'hire.preview.console',args).catch(e=>{throw this.#refused(s,new BusError(e.code??'outcome-unknown'),request);});
if(request.verb==='decision.preview.console' && ['role.hire','role.fire','role.change'].includes(this.#decision(s,args.id).action))return this.#hireConsole(s,'hire.preview.console',args).catch(e=>{throw this.#refused(s,new BusError(e.code??'outcome-unknown',e instanceof BusError?e.reason:undefined),request);});
if (['hire.preview.console','hire.resolve.console'].includes(request.verb))
return this.#hireConsole(s,request.verb,args).catch(e=>{throw this.#refused(s,new BusError(e.code??'outcome-unknown'),request);});
return this.#hireConsole(s,request.verb,args).catch(e=>{throw this.#refused(s,new BusError(e.code??'outcome-unknown',e instanceof BusError?e.reason:undefined),request);});
if (request.verb === 'grants.scope' || request.verb === 'grants.scope.set')
return this.#grantScopeVerb(s, request.verb, structuredClone(args));
// Ruling 2026-11-14: hire a pack's proposed agents after the apply that recorded them, through
// the same loop a person's apply runs. pack.hire is the owner's CLI human cap; pack.hire.console
// the owner's or a member's console cap. An agent and the tester never get here.
if (request.verb === 'pack.hire' || request.verb === 'pack.hire.console') {
if (s.tester) fail('tester-refused');
if ((request.verb === 'pack.hire.console') !== !!s.console) fail('human-required');
keys(args, ['pack', 'project'], ['pack']);
if (typeof args.pack !== 'string' || !/^(saved:)?[a-z0-9][a-z0-9._-]{0,63}$/.test(args.pack)) fail('invalid-request');
if (Object.hasOwn(args, 'project') && (typeof args.project !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(args.project))) fail('invalid-request');
const callerOf = () => this.#packHireCaller(s);
if (!callerOf().rights.includes('org.hire')) fail('right-required');
return Promise.resolve().then(async () => {
const state = this.#organization ? this.#organization(s.business, 'pack.state', { pack: args.pack, project: args.project ?? null }, s.human, {}) : null;
if (!state?.entry) fail('pack-not-applied');
const out = await this.#packHires(s, callerOf, { pack: args.pack, project: args.project ?? null });
this.#secretCheck(out); return { pack: state.entry.id, ...out };
}).catch(e => { if (e instanceof BusError) throw this.#refused(s, e, request); this.#packFail(e); });
}
// #1873 SP4: the owner's starter packs, board and workflows. Only the organization's owner calls
// them: the human cap from the CLI, or the owner's console cap (a hire member's cap is refused
// above). The tester is refused before any argument check. A preview and an apply raise no
@@ -6337,6 +6366,20 @@ export class Broker {
if (spends && wrote) this.#store.transaction(() => this.#consumeAuthority(s, 'organization.change'));
this.#secretCheck(value); return value;
};
// Ruling 2026-11-14: a person's apply is the hire decision. Once the apply has committed, the
// same call hires the proposals (#packHires); an agent's apply never hires.
// The apply has committed by then, so a hire loop that throws (organization-busy, a store error)
// still returns the apply's receipt, with no hires and the loop's code as hireError.
if (verb === 'pack.apply' && !agent) {
const hired = async (value) => {
let out;
try { out = await this.#packHires(s, () => this.#packHireCaller(s), { pack: args.pack, project: args.project ?? null }); }
catch (e) { out = { hires: [], hireError: e instanceof BusError && typeof e.code === 'string' ? e.code : 'outcome-unknown' }; }
return done({ ...value, ...out });
};
return Promise.resolve(result).then(value => value, packFail).then(hired);
}
if (verb === 'packs') return Promise.resolve(result).then(value => done(this.#packsEnrich(s.business, value)), packFail);
return result?.then ? result.then(done, packFail) : done(result);
}
// #1873 SP8: saving a template. Only the organization's owner: the human cap from the CLI or the
@@ -6458,6 +6501,12 @@ export class Broker {
entry.running = this.#running(s.business, name);
entry.alive = this.#aliveAfterFire(s.business, name);
}
// Ruling 2026-11-14: each instance a pack hire created names the pack, from its pack.hire event.
if (request.verb === "instances" && result?.instances && typeof result.instances === "object") {
const from = this.#packHireOrigins(s.business);
for (const entry of Object.values(result.instances))
if (typeof entry.hireDecision === 'string' && from.has(entry.hireDecision)) entry.pack = from.get(entry.hireDecision);
}
// #1873 A3: the copies this bus booted with, and each one's running runs. The file's own
// instances above carry no copy; a copy carries its state, missing service names or reason.
if (request.verb === "instances" && result?.instances && typeof result.instances === "object" && this.#business(s.business).copies)
@@ -6628,7 +6677,7 @@ export class Broker {
if(!this.#autonomyHost?.get || !this.#autonomyHost?.set)fail('not-configured');
const old=await this.#autonomyHost.get(s.business),b=this.#business(s.business);
if(a.revision!==old.revision)fail('revision-conflict');
if(AUTONOMY_CLASSES.some(cls=>decisionAutonomy(cls,a.autonomy)==='near the loop') && a.autonomy.notices!==true)fail('autonomy-precondition');
if(AUTONOMY_CLASSES.some(cls=>decisionAutonomy(cls,a.autonomy)==='near the loop') && a.autonomy.notices!==true)fail('autonomy-precondition','owner notices are off; a class near the loop needs them on');
for(const cls of AUTONOMY_CLASSES) {
const before=decisionAutonomy(cls,old.autonomy),after=decisionAutonomy(cls,a.autonomy);
// Pulling back is unconditional. Only a move away from the loop has prerequisites.
@@ -6637,22 +6686,24 @@ export class Broker {
if(cls==='policy')continue;
if(cls==='authority' && after==='out of the loop' && before!==after)fail('authority-limits-unavailable');
if(['in the loop','near the loop','out of the loop'].indexOf(after)<=['in the loop','near the loop','out of the loop'].indexOf(before))continue;
if(a.autonomy.notices!==true || !this.#autonomyHost.reversible?.(cls,b))fail('autonomy-precondition');
if(a.autonomy.notices!==true)fail('autonomy-precondition',`owner notices are off; moving ${cls} away from the loop needs them on`);
if(!this.#autonomyHost.reversible?.(cls,b))fail('autonomy-precondition',`${cls} has no tested reverse in this organization, so it stays in the loop`);
const resolvers=cls==='authority'?[a.autonomy.authorityResolver]:cls==='merge'?[b.arbiters.technical]:cls==='policy'?[b.arbiters.delivery]:Object.values(b.arbiters);
for(const name of resolvers) {
const role=b.roles[name],right=cls==='authority'?'decision.resolve.authority':`decision.resolve.${cls==='merge'?'technical':cls==='policy'?'delivery':name===b.arbiters.technical?'technical':'delivery'}`;
if(!role?.authority?.withinRole.includes(right) || (cls==='authority' && name===b.launch?.by))fail('autonomy-precondition');
if(!role?.authority?.withinRole.includes(right))fail('autonomy-precondition',cls==='authority'?'the authority resolver is not a role with decision.resolve.authority':`the ${cls} resolver is not a role with ${right}`);
if(cls==='authority' && name===b.launch?.by)fail('autonomy-precondition','the authority resolver is the role that launches agents; name a separate resolver');
}
if(['merge','policy'].includes(cls) && !Object.values(b.roles).some(r=>r.authority?.withinRole.includes('review.verdict')))fail('autonomy-precondition');
if(cls==='authority' && !this.#budgetCovered(b))fail('autonomy-precondition');
if(['merge','policy'].includes(cls) && !Object.values(b.roles).some(r=>r.authority?.withinRole.includes('review.verdict')))fail('autonomy-precondition',`no role holds review.verdict, which ${cls} away from the loop needs`);
if(cls==='authority' && !this.#budgetCovered(b))fail('autonomy-precondition',BUDGET_UNCOVERED);
if(after==='out of the loop') {
if(before!=='near the loop')fail('autonomy-precondition');
if(before!=='near the loop')fail('autonomy-precondition',`${cls} moves out of the loop only from near the loop`);
const review=this.#store.get("SELECT seq,body FROM events WHERE business=? AND kind='action.allowed' AND json_extract(body,'$.operation')='autonomy.review' AND json_extract(body,'$.decisionClass')=? ORDER BY seq DESC LIMIT 1",s.business,cls);
const latest=this.#store.get("SELECT seq FROM events WHERE business=? AND kind='action.allowed' AND json_extract(body,'$.operation')='autonomy.set' ORDER BY seq DESC LIMIT 1",s.business);
if(!review || JSON.parse(review.body).settingSeq!==latest?.seq)fail('autonomy-precondition');
if(!review || JSON.parse(review.body).settingSeq!==latest?.seq)fail('autonomy-precondition',`${cls} needs your review of its trail since the last autonomy change`);
const notice=this.#store.get("SELECT seq FROM events WHERE business=? AND kind='action.allowed' AND json_extract(body,'$.operation')='autonomy.notice' AND json_extract(body,'$.decisionClass')=? AND seq>? ORDER BY seq DESC LIMIT 1",s.business,cls,latest?.seq??0);
const reversal=this.#store.get("SELECT max(e.seq) seq FROM events e WHERE e.business=? AND e.kind='action.allowed' AND json_extract(e.body,'$.operation') LIKE 'autonomy.reverse%' AND EXISTS(SELECT 1 FROM events n WHERE n.business=e.business AND n.kind='action.allowed' AND json_extract(n.body,'$.operation')='autonomy.notice' AND json_extract(n.body,'$.decisionClass')=? AND json_extract(n.body,'$.decision')=json_extract(e.body,'$.decision'))",s.business,cls);
if(!notice || review.seq<=Math.max(notice.seq,reversal?.seq??0))fail('autonomy-precondition');
if(!notice || review.seq<=Math.max(notice.seq,reversal?.seq??0))fail('autonomy-precondition',`${cls} needs a near-loop decision since the last autonomy change, and your trail review after it`);
}
}
this.#store.transaction(()=>this.#event(s,'action.allowed',{operation:'autonomy.set.requested',autonomy:a.autonomy,subject:s.console},null));
@@ -6736,28 +6787,162 @@ export class Broker {
.at(-1);
if (!entry) fail('invalid-request');
const hire = entry.proposedHires.find(h => h.name === proposal.hire);
const pin = hire.pin;
if (!object(pin)) fail('invalid-request');
let role;
if (Object.hasOwn(pin, 'inline')) {
if (!object(hire.entry) || typeof pin.sha256 !== 'string') fail('invalid-request');
// The broker's sandbox import closure is fixed, so the digest and the composition are local
// copies: canonical is organization util.mjs canonicalJson, built as a string so integer-like
// keys keep the sorted order (an object would put them first), and the composition is
// definitions.mjs compositionOf.
const canonical = v => Array.isArray(v) ? `[${v.map(canonical).join(',')}]` : object(v)
? `{${Object.keys(v).sort().map(k => `${JSON.stringify(k)}:${canonical(v[k])}`).join(',')}}` : JSON.stringify(v);
if (sha256(canonical(hire.entry)) !== pin.sha256) fail('starter-pack-proposal-stale');
const from = hire.entry.from?.template;
if (from !== undefined && (b.launch?.noHire ?? []).includes(from)) fail('definition-not-hireable');
if (!object(hire.entry.role) || typeof hire.entry.instructions !== 'string') fail('invalid-request');
role = { inline: { ...hire.entry.role, instructions: hire.entry.instructions, ...(hire.entry.personality !== undefined ? { personality: hire.entry.personality } : {}) } };
} else role = structuredClone(pin);
const role = this.#pinRole(b.launch?.noHire ?? [], hire);
const reason = Object.hasOwn(args, 'reason') ? args.reason : hire.reason;
return { op: 'hire', level: project === null ? 'org' : 'project', ...(project === null ? {} : { project }), name: hire.name, role, route: structuredClone(args.route), reason };
return { input: { op: 'hire', level: project === null ? 'org' : 'project', ...(project === null ? {} : { project }), name: hire.name, role, route: structuredClone(args.route), reason },
pack: { pack: entry.id, version: entry.version ?? null, origin: entry.origin ?? null, project } };
}
async #raiseHire(s, input, immediate) {
// A recorded proposal's pin as a hire request's role (SP5's chief raise and a person's pack hire).
#pinRole(noHire, hire) {
const pin = hire?.pin;
if (!object(pin)) fail('invalid-request');
// #1873 triage-fence: a recorded pin never hires a system-only template, by reference or as the
// inline copy of one (the inline composition below drops from).
if (systemOnly(pin.template) || systemOnly(hire.entry?.from?.template)) fail(SYSTEM_ONLY_REFUSAL);
if (!Object.hasOwn(pin, 'inline')) return structuredClone(pin);
if (!object(hire.entry) || typeof pin.sha256 !== 'string') fail('invalid-request');
// The broker's sandbox import closure is fixed, so the digest and the composition are local
// copies: canonical is organization util.mjs canonicalJson, built as a string so integer-like
// keys keep the sorted order (an object would put them first), and the composition is
// definitions.mjs compositionOf.
const canonical = v => Array.isArray(v) ? `[${v.map(canonical).join(',')}]` : object(v)
? `{${Object.keys(v).sort().map(k => `${JSON.stringify(k)}:${canonical(v[k])}`).join(',')}}` : JSON.stringify(v);
if (sha256(canonical(hire.entry)) !== pin.sha256) fail('starter-pack-proposal-stale');
const from = hire.entry.from?.template;
if (from !== undefined && noHire.includes(from)) fail('definition-not-hireable');
if (!object(hire.entry.role) || typeof hire.entry.instructions !== 'string') fail('invalid-request');
return { inline: { ...hire.entry.role, instructions: hire.entry.instructions, ...(hire.entry.personality !== undefined ? { personality: hire.entry.personality } : {}) } };
}
// Ruling 2026-11-14: a person's pack apply is the hire decision. The person who may hire from a
// pack: the owner's console cap, the owner's CLI human cap (outside any run), or a member's console
// cap with org.hire. Anyone else is refused human-required; the tester tester-refused.
#packHireCaller(s) {
if (s.tester) fail('tester-refused');
if (s.console) return this.#hireCaller(s);
this.#human(s);
if (s.human !== this.#business(s.business).human) fail('human-required');
return { actor: s.human, agent: false, rights: ['org.hire'], owner: true, instanceOwner: false, subject: null, via: 'cli' };
}
#openHireDecisions(business) {
return this.#store.all(`SELECT d.id FROM decisions d WHERE d.business=? AND d.action='role.hire' AND NOT EXISTS(SELECT 1 FROM decision_events x WHERE x.decision=d.id AND x.op IN ${CLOSED}) ORDER BY d.at, d.id`, business)
.map(({ id }) => ({ id, hire: this.#raised(business, id)?.hire })).filter(x => object(x.hire));
}
// decision id -> {id, origin, project} of the pack whose hire raised it.
#packHireOrigins(business) {
return new Map(this.#packHireEvents(business).filter(e => e.operation === 'pack.hire' && typeof e.decision === 'string')
.map(e => [e.decision, { id: e.pack, origin: e.origin ?? null, project: e.project ?? null }]));
}
// Ruling 2026-11-14: the packs read gains, per applied entry, the agents its hires created
// (launched, for the organization level) and each proposal still open: awaiting-owner with its
// decision, refused with the last refusal code, or proposed. Each carries the pack's reason.
#packsEnrich(business, value) {
if (!Array.isArray(value?.applied)) return value;
const events = this.#packHireEvents(business), agents = value.agents ?? { org: {}, projects: {} };
const open = new Map(this.#openHireDecisions(business).map(x => [JSON.stringify([x.hire.name, x.hire.project ?? null]), x.id]));
const raisedBy = new Map(events.filter(e => e.operation === 'pack.hire').map(e => [e.decision, e]));
for (const a of value.applied) {
const level = a.project === null ? agents.org ?? {} : agents.projects?.[a.project] ?? {};
const mine = e => e.pack === a.id && (e.origin ?? null) === (a.origin ?? null) && (e.project ?? null) === (a.project ?? null);
// Hired: every live instance at the entry's level a hire of this pack created, whichever entry
// proposed it (a re-apply records an entry that proposes nothing new).
a.hired = Object.entries(level).filter(([, inst]) => inst.launched && inst.hireDecision && raisedBy.has(inst.hireDecision) && mine(raisedBy.get(inst.hireDecision))).map(([name]) => name);
a.open = [];
for (const h of a.proposedHires) {
if (Object.hasOwn(level, h.name)) continue;
const decision = open.get(JSON.stringify([h.name, a.project ?? null]));
// fromPack: this pack's own hire raised it, so the owner's pack hire replaces and approves it.
if (decision) { a.open.push({ name: h.name, reason: h.reason, state: 'awaiting-owner', decision, ...(raisedBy.has(decision) && mine(raisedBy.get(decision)) ? { fromPack: true } : {}) }); continue; }
const last = events.filter(e => mine(e) && e.hire === h.name).at(-1);
if (last?.operation === 'pack.hire.refused') a.open.push({ name: h.name, reason: h.reason, state: 'refused', code: last.code });
else a.open.push({ name: h.name, reason: h.reason, state: 'proposed' });
}
}
return value;
}
#packHireEvents(business) {
return this.#store.all(`SELECT body FROM events WHERE business=? AND kind='action.allowed' AND json_extract(body,'$.operation') IN ('pack.hire','pack.hire.refused') ORDER BY seq`, business)
.map(r => JSON.parse(r.body));
}
// One pass over the latest packs entry of `pack` (and project): each proposed hire is raised and
// approved in the same act through #raiseHire and #hireConsole, the path an inbox approval takes, so
// each agent leaves the same decision record. A hire whose instance exists, or that an open hire
// decision already names, is skipped, so a re-apply hires nothing twice. The owner approves every
// line. A member approves only the unflagged hires; each flagged or credentialed one is recorded
// after them, pinned to the final revision, as an open decision for the owner's inbox. A hire that
// refuses records action.allowed pack.hire.refused with its code, and the loop goes on.
async #packHires(s, callerOf, { pack, project = null }) {
if (!this.#organization || !this.#hires) fail('not-configured');
if (this.#packHiring.has(s.business)) fail('organization-busy');
this.#packHiring.add(s.business);
try { return await this.#packHireLoop(s, callerOf, { pack, project }); }
finally { this.#packHiring.delete(s.business); }
}
async #packHireLoop(s, callerOf, { pack, project }) {
const caller = callerOf();
const read = () => this.#organization(s.business, 'pack.state', { pack, project }, caller.actor, {});
const state = read();
if (!state?.entry) return { hires: [] };
const entry = state.entry, provenance = { pack: entry.id, version: entry.version ?? null, origin: entry.origin ?? null, project };
const out = [], deferred = [];
const refused = (name, e) => {
const code = e?.code ?? 'outcome-unknown';
this.#store.transaction(() => this.#event(s, 'action.allowed', { operation: 'pack.hire.refused', pack: entry.id, origin: entry.origin ?? null, project, hire: name, code }, null));
out.push({ name, state: 'refused', code });
};
const open = new Map(this.#openHireDecisions(s.business).map(x => [JSON.stringify([x.hire.name, x.hire.project ?? null]), x.id]));
const raisedBy = new Map(this.#packHireEvents(s.business).filter(e => e.operation === 'pack.hire').map(e => [e.decision, e]));
for (const hire of (Array.isArray(entry.proposedHires) ? entry.proposedHires : []).filter(object)) {
const name = hire.name;
if (state.names.includes(name)) { out.push({ name, state: 'exists' }); continue; }
const openId = open.get(JSON.stringify([name, project]));
// The owner's pack hire approves every line, so an open decision an earlier pack hire of this
// same pack left for the owner is replaced by one approved now (its pin may be stale after the
// hires approved since). The old one is withdrawn only once the new hire has applied: a
// replacement that refuses leaves it open in the owner's inbox. Any other open decision is left alone.
let supersedes = null;
if (openId) {
const by = raisedBy.get(openId);
if (caller.owner !== true || !by || by.pack !== entry.id || (by.origin ?? null) !== (entry.origin ?? null) || (by.project ?? null) !== project) { out.push({ name, state: 'open', decision: openId }); continue; }
supersedes = openId;
}
let input;
try {
if (!state.route) fail('pack-hire-route-missing');
input = { op: 'hire', level: project === null ? 'org' : 'project', ...(project === null ? {} : { project }), name, role: this.#pinRole(state.noHire, hire), route: structuredClone(state.route),
reason: typeof hire.reason === 'string' && hire.reason.trim() ? hire.reason : `Proposed by starter pack ${entry.id}.` };
} catch (e) { refused(name, e); continue; }
let r;
try {
r = await this.#raiseHire(s, input, true, { caller: callerOf, pack: provenance, defer: caller.owner !== true });
} catch (e) { refused(name, e); continue; }
if (r?.deferred) { deferred.push(input); continue; }
if (supersedes) this.#store.transaction(() => {
if (this.#closed(supersedes)) return;
const seq = Number(this.#store.run('INSERT INTO decision_events(decision,at,op,by,choice,note,via) VALUES(?,?,?,?,?,?,?)',
supersedes, this.#now(), 'withdrawn', caller.actor, null, null, caller.via ?? 'console').lastInsertRowid);
this.#event(s, 'human.input', { kind: 'answer', decision: supersedes, op: 'withdrawn', choice: null, via: caller.via ?? 'console', subject: caller.via === 'cli' ? null : s.console, decisionSeq: seq }, supersedes);
});
out.push({ name, state: 'hired', decision: r.id, routeFrom: state.routeFrom, ...(supersedes ? { supersedes } : {}) });
}
for (const input of deferred) {
try {
const r = await this.#raiseHire(s, input, false, { caller: callerOf, pack: provenance, record: true });
out.push({ name: input.name, state: 'awaiting-owner', decision: r.id, routeFrom: state.routeFrom });
} catch (e) { refused(input.name, e); }
}
return { hires: out };
}
// opts (ruling 2026-11-14, a person's pack apply is the hire decision):
// caller: () => the person's hire caller, read again after prepare. Default #hireCaller(s).
// pack: {pack, version, origin, project}; the raise also records action.allowed pack.hire.
// defer: a flagged or credentialed hire a non-owner may not approve returns {deferred: true}
// instead of refusing hire-owner-required, and records nothing.
// record: the person's raise is left open for the owner's inbox (route human, not resolved).
async #raiseHire(s, input, immediate, opts = {}) {
const b=this.#business(s.business);
const human=immediate || opts.record===true;
const callerOf=()=>opts.caller ? opts.caller() : this.#hireCaller(s);
// Change is a replacement composition and uses the existing role.hire grant.
const chiefAllowed=()=>{
this.#agent(s);
@@ -6767,36 +6952,44 @@ export class Broker {
};
// #1873 CB1: a copy credential binding is owner-only. A person raising one in one step must be
// the organization's owner; a member with org.hire is not.
if(immediate) { const c=this.#hireCaller(s); if(!c.rights.includes('org.hire'))fail('right-required'); if(input?.binding!==undefined && c.owner!==true)fail('human-required'); }
if(human) { const c=callerOf(); if(!c.rights.includes('org.hire'))fail('right-required'); if(input?.binding!==undefined && c.owner!==true)fail('human-required'); }
else chiefAllowed();
if(!this.#hires)fail('not-configured');
const did=randomUUID(), at=this.#now(), expiresAt=new Date(Date.parse(at)+7*86400000).toISOString();
const p=await this.#hires.prepare(s.business,structuredClone(input),{id:did,expiresAt});
// Recheck the chief after asynchronous preparation; a released run cannot raise.
if(!immediate)chiefAllowed();
let caller=null;
if(!human)chiefAllowed();
else {
const caller=this.#hireCaller(s);
caller=callerOf();
if(p.binding && caller.owner!==true)fail('human-required');
if(!p.binding && (((p.flagged.length || p.credentialLines.length) && !caller.owner) || (p.level==='root' && !caller.instanceOwner)))fail('hire-owner-required');
const ownerOnly=!p.binding && (((p.flagged.length || p.credentialLines.length) && !caller.owner) || (p.level==='root' && !caller.instanceOwner));
if(ownerOnly && opts.defer===true)return {deferred:true,name:p.name,flagged:p.flagged,credentialLines:p.credentialLines};
if(ownerOnly && opts.record!==true)fail('hire-owner-required');
}
const action=`role.${p.op}`;
const level=decisionAutonomy('authority',b.autonomy);
let route='human';
// A binding always goes to the owner; no autonomy level moves it (design section 4).
if(!immediate && !p.binding && level!=='in the loop' && p.level!=='root' && !p.flagged.length && !p.credentialLines.length) {
if(!human && !p.binding && level!=='in the loop' && p.level!=='root' && !p.flagged.length && !p.credentialLines.length) {
if(level==='out of the loop')fail('authority-limits-unavailable');
if(!this.#budgetCovered(this.#business(s.business)))fail('autonomy-precondition');
if(!this.#budgetCovered(this.#business(s.business)))fail('autonomy-precondition',BUDGET_UNCOVERED);
route=b.autonomy?.authorityResolver;
if(!b.roles[route]?.authority?.withinRole.includes('decision.resolve.authority'))fail('autonomy-precondition');
if(!b.roles[route]?.authority?.withinRole.includes('decision.resolve.authority'))fail('autonomy-precondition','the authority resolver is not a role with decision.resolve.authority');
if(route===s.role || resolverSubject(b,route,p.name))route='human';
}
this.#store.transaction(()=>{
const raiser=immediate?'human':s.role;
const raiser=human?'human':s.role;
const run=human?(caller?.via==='cli'?'human-cli':'human-console'):s.run;
this.#store.run('INSERT INTO decisions(id,at,business,project,raised_by_role,raised_by_run,class,action,route_to,question,options,recommendation,blocking) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?)',
did,at,s.business,p.project??null,raiser,immediate?'human-console':s.run,'gated',action,route,p.binding?`${p.binding.after===null?'unbind':'bind'} credentials for copy ${p.binding.instance}?`:`${p.op} ${p.name} at ${p.level} level?`,JSON.stringify([{key:'yes',text:'Approve'},{key:'no',text:'Deny'}]),'no',0);
did,at,s.business,p.project??null,raiser,run,'gated',action,route,p.binding?`${p.binding.after===null?'unbind':'bind'} credentials for copy ${p.binding.instance}?`:`${p.op} ${p.name} at ${p.level} level?`,JSON.stringify([{key:'yes',text:'Approve'},{key:'no',text:'Deny'}]),'no',0);
this.#event(s,'action.allowed',{operation:'decision.raise',decision:did,action,approvalChoice:'yes',target:p.name,hire:p,autonomyLevel:level},did);
// The pack this hire came from, for the Agents page and the pack card. No target key: the
// decision.raise above is the record the decision readers key on.
if(opts.pack)this.#event(s,'action.allowed',{operation:'pack.hire',pack:opts.pack.pack,version:opts.pack.version??null,origin:opts.pack.origin??null,project:opts.pack.project??null,hire:p.name,decision:did},did);
});
if(immediate) return this.#hireConsole(s,'hire.resolve.console',{id:did,choice:'yes',digest:p.digest});
if(immediate) return this.#hireConsole(s,'hire.resolve.console',{id:did,choice:'yes',digest:p.digest},opts.caller ?? null);
if(human) return {id:did,op:'raised',name:p.name,flagged:p.flagged,credentialLines:p.credentialLines};
return {...this.#decisionView(this.#decision(s,did)),hire:bindingSummary(p)};
}
// The harness fact comes from the host's loaded modules; no host, no account coverage.
@@ -6818,7 +7011,7 @@ export class Broker {
if(this.#expireHire(s,d,p))fail('decision-expired');
if(this.#autonomyLevel(d)==='in the loop')fail('hire-resolution-required');
if(this.#autonomyLevel(d)==='out of the loop')fail('authority-limits-unavailable');
if(!this.#budgetCovered(this.#business(s.business)))fail('autonomy-precondition');
if(!this.#budgetCovered(this.#business(s.business)))fail('autonomy-precondition',BUDGET_UNCOVERED);
if(!this.#business(s.business).roles[s.role]?.authority?.withinRole.includes('decision.resolve.authority'))fail('not-resolver');
};
validate();
@@ -6838,7 +7031,7 @@ export class Broker {
const recheck=()=>{
this.#agent(s);
if(this.#autonomyLevel(d)==='out of the loop')fail('authority-limits-unavailable');
if(!this.#budgetCovered(this.#business(s.business)))fail('autonomy-precondition');
if(!this.#budgetCovered(this.#business(s.business)))fail('autonomy-precondition',BUDGET_UNCOVERED);
if(this.#autonomyLevel(d)==='in the loop' || !this.#business(s.business).roles[s.role]?.authority?.withinRole.includes('decision.resolve.authority') || resolverSubject(this.#business(s.business),s.role,p.name))fail('not-resolver');
};
recheck();
@@ -6853,8 +7046,8 @@ export class Broker {
this.#store.transaction(()=>this.#event(s,'action.allowed',{operation:'hire.failed',decision:d.id,code:error.code??'outcome-unknown'},d.id));throw error;
}
}
async #hireConsole(s,verb,a) {
const caller={...this.#hireCaller(s),now:()=>Math.max(Date.now(),this.#clock)};
async #hireConsole(s,verb,a,callerOf=null) {
const caller={...(callerOf ? callerOf() : this.#hireCaller(s)),now:()=>Math.max(Date.now(),this.#clock)};
keys(a,verb==='hire.preview.console'?['id','adjust']:['id','choice','digest','adjust'],verb==='hire.preview.console'?['id']:['id','choice','digest']);
identifier(a.id);
const d=this.#decision(s,a.id), raise=this.#raised(s.business,d.id);
@@ -6877,8 +7070,9 @@ export class Broker {
// A durable close/consume precedes the external file effect. A crash never replays an approval.
this.#store.transaction(()=>{
if(this.#closed(d.id))fail('decision-closed');
this.#store.run('INSERT INTO decision_events(decision,at,op,by,choice,via) VALUES(?,?,?,?,?,?)',d.id,this.#now(),'resolved',caller.actor,a.choice,'console');
this.#event(s,'human.input',{kind:'answer',decision:d.id,op:'resolved',choice:a.choice,via:'console',subject:s.console},d.id);
const via=caller.via ?? 'console';
this.#store.run('INSERT INTO decision_events(decision,at,op,by,choice,via) VALUES(?,?,?,?,?,?)',d.id,this.#now(),'resolved',caller.actor,a.choice,via);
this.#event(s,'human.input',{kind:'answer',decision:d.id,op:'resolved',choice:a.choice,via,subject:callerOf ? caller.subject ?? null : s.console},d.id);
if(a.choice==='yes')this.#event(s,'action.allowed',{operation:'hire.consume',decision:d.id,digest:p.digest,hire:p},d.id);
});
if(a.choice==='no')return {id:d.id,op:'resolved',choice:a.choice};
@@ -7016,7 +7210,7 @@ export class Broker {
// name; a file check (BusinessError) is invalid-request, anything else outcome-unknown.
#packFail(e) {
const code = e?.code ?? '';
if (['credential-leak', 'pack-plan-stale', 'revision-conflict', 'invalid-request', 'human-required', 'not-configured'].includes(code)
if (['credential-leak', 'pack-plan-stale', 'revision-conflict', 'invalid-request', 'human-required', 'not-configured', SYSTEM_ONLY_REFUSAL].includes(code)
|| /^(starter-pack|definition|organization)-[a-z-]+$/.test(code)) fail(code);
if (e?.name === 'BusinessError') fail('invalid-request');
throw new BusError('outcome-unknown');
@@ -7048,6 +7242,8 @@ export class Broker {
if ((verb === "instance.hire" || verb === "instance.fire") && e.code === "definition-not-hireable") fail(e.code);
// Row 194 (B7, webby-0094 N3): the limits writer's keep check, against the file, as well.
if (e.code === "instance-kept") fail(e.code);
// #1873 triage-fence: a system-only template refuses by its one code on every write.
if (e.code === SYSTEM_ONLY_REFUSAL) fail(e.code);
// #1873 T1: the definition writer's refusals pass by code; a composition refusal stays invalid-request.
if (Object.hasOwn(DEFINITION_BUS_KEYS, verb) && /^definition-[a-z-]+$/.test(e.code ?? "")) fail(e.code);
// Row 194 (brief item 8): a fire's or a delete's revoke failed, and nothing was written.
+14 -3
View File
@@ -1,5 +1,11 @@
import { connect } from 'node:net';
import { BusError, PROJECT_SAVE_VERB, PROJECT_SAVE_REQUEST_MAX } from './broker.mjs';
// E2E6 fix 6: a connect that fails with one of these never sent the request. The code stays
// outcome-unknown for every caller that reads it (the harness, the Console), and the error is marked
// notSent so the human and tester shims can exit with NOT_SENT_EXIT and `mosaic` can say the bus is
// not running.
const NOT_SENT = new Set(['ENOENT', 'ECONNREFUSED', 'ENOTDIR', 'ENOTSOCK']);
export const NOT_SENT_EXIT = 5;
export class Client {
constructor({ path, cap, human, tester, user, console: owner, timeout = 5000 }) {
this.path = path;
@@ -22,7 +28,8 @@ export class Client {
return new Promise((resolve, reject) => {
const socket = connect(this.path);
let input = Buffer.alloc(0),
settled = false;
settled = false,
connected = false;
const end = (error, value) => {
if (settled) return;
settled = true;
@@ -30,8 +37,12 @@ export class Client {
error ? reject(error) : resolve(value);
};
socket.setTimeout(['processing.halt', 'processing.resume'].includes(verb) ? Math.max(this.timeout, 20000) : this.timeout, () => end(new BusError('outcome-unknown')));
socket.on('connect', () => socket.write(request));
socket.on('error', () => end(new BusError('outcome-unknown')));
socket.on('connect', () => { connected = true; socket.write(request); });
socket.on('error', (error) => {
const unknown = new BusError('outcome-unknown');
if (!connected && NOT_SENT.has(error?.code)) unknown.notSent = true;
end(unknown);
});
socket.on('end', () => end(new BusError('outcome-unknown')));
socket.on('data', (b) => {
input = Buffer.concat([input, b]);
+4 -2
View File
@@ -3,7 +3,7 @@ import { randomBytes } from 'node:crypto';
import { spawnSync } from 'node:child_process';
import { fileURLToPath } from 'node:url';
import { readFileSync } from 'node:fs';
import { Client } from './client.mjs';
import { Client, NOT_SENT_EXIT } from './client.mjs';
import { readProcess } from './human.mjs';
const file = fileURLToPath(import.meta.url);
if (!process.env.MOSAIC_BUS_CLI_NONCE) {
@@ -39,5 +39,7 @@ try {
process.stdout.write(JSON.stringify(result) + '\n');
} catch (e) {
process.stderr.write((/^[a-z-]{1,64}$/.test(e.code ?? '') ? e.code : 'invalid-request') + '\n');
process.exitCode = 2;
// E2E6 fix 6: a request that never left (no socket, or the connect refused) keeps its code and
// exits NOT_SENT_EXIT, so `mosaic` can say the bus is not running. Every other failure exits 2.
process.exitCode = e?.notSent === true ? NOT_SENT_EXIT : 2;
}
+17 -3
View File
@@ -6,6 +6,8 @@ import { isDeepStrictEqual } from 'node:util';
import { BusError } from './broker.mjs';
export const REVOKE_TIMEOUT_MS = 5000;
export const REVOKE_POLL_MS = 25;
export const ISSUE_PROBE_TIMEOUT_MS = 2000;
export const ISSUE_REPROBE_MIN_MS = 250;
export const MODEL_STOP_TIMEOUT_MS = 5000;
const keyId = key => createHash('sha256').update(key).digest('hex').slice(0, 12);
const fail = code => { throw new BusError(code); };
@@ -223,9 +225,21 @@ export class ModelKeys {
this.#sentinel(keys);
return this.#issue(instance, false, keys);
});
let status;
try { status = await this.#client.probeKey(proxy.key); }
catch { fail('proxy-down'); }
// Every v8 CLIProxyAPI applies a key-list PUT by an async reload after it answers, so a
// just-issued key can answer 401 for a moment. On 8.0.79 that moment outlasts the confirming
// GET (measured, #1873). Only 401 is probed again, until a short deadline; a re-probe waits
// about the time left, at least ISSUE_REPROBE_MIN_MS. Any other non-2xx refuses on the first
// answer, as before.
const deadline = performance.now() + ISSUE_PROBE_TIMEOUT_MS;
let status, first = true;
for (;;) {
const options = first ? undefined : { timeout: Math.max(ISSUE_REPROBE_MIN_MS, Math.ceil(deadline - performance.now())) };
first = false;
try { status = await this.#client.probeKey(proxy.key, options); }
catch { fail('proxy-down'); }
if (status !== 401 || performance.now() >= deadline) break;
await new Promise(resolve => setTimeout(resolve, REVOKE_POLL_MS));
}
if (status < 200 || status >= 300) fail('proxy-key-refused');
return proxy;
}
+26
View File
@@ -199,6 +199,13 @@ group(
"R10: only the caller's own saved templates",
"List your saved templates and use one of those names. A saved template is visible only to the owner who saved it."
);
// #1873 triage-fence: a template on the system-only list (organization vocabulary.mjs SYSTEM_ONLY)
// joins no organization by any path.
group(
"template-system-only",
"R8/R10: a system-only role template joins no organization",
"This role template serves the system outside every organization. Pick another template or definition; no hire, change, pack, import or instance write gives an organization one."
);
group(
"starter-pack-template-changed",
"R8: a pack's hash pin must match the current template",
@@ -218,6 +225,19 @@ group(
"R8: a hire raised from a pack proposal matches its recorded pin",
"The role entry stored with this proposal no longer matches the hash it was recorded with. Preview and apply the pack again for a fresh proposal, then raise the hire from that one."
);
// Ruling 2026-11-14: a person's pack apply is the hire decision. The hire action works from the packs
// entry an apply recorded, and each hire runs as the chief's harness and model, else the org
// assistant's (lane pr2).
group(
"pack-not-applied",
"R8: a pack hire works from the packs entry an apply recorded",
"Preview and apply the pack first; its proposed hires come from the packs entry that apply records."
);
group(
"pack-hire-route-missing",
"R3/R8: a hire runs as a harness and model the organization names",
"Neither the chief of staff nor the organization's assistant resolves a harness and a model. Give the chief of staff or the assistant both in its vars, or set them at the organization or system level, then use the pack's hire action again."
);
// #1873 SP8: a saved template carries no credential the bus holds. Save checks every kept string and
// key against the credential store; a hit names the field, never the text.
group(
@@ -225,6 +245,12 @@ group(
"R1/R10: a saved template carries no credential value the bus holds",
"A field the template would keep holds a credential value. Remove it from the named definition, board or workflow text, then preview and save again."
);
// E2E6 fix 8: save never replaces a template already saved under the name.
group(
"template-exists",
"R10: a saved template is never replaced",
"A template of this name is already saved for your account. Save under another name, or list your saved templates to pick a free one."
);
group(
"not-resolver",
"Role resolve right and decision route",
+150 -13
View File
@@ -32,7 +32,7 @@ import { loadManagementClient } from '../../model-proxy/src/client.mjs';
import { ProxyPage } from './proxy-page.mjs';
import { createModelCatalogue } from './model-catalogue.mjs';
import { sha256 } from '../../model-proxy/src/common.mjs';
import { initializeProxy } from '../../model-proxy/src/settings.mjs';
import { initializeProxy, loadProxy } from '../../model-proxy/src/settings.mjs';
import { createProxyLock } from './proxy-lock.mjs';
import { verifyRestart } from '../../model-proxy/src/admin.mjs';
import { ModelKeys, modelOrganization, stopModelRuns, MODEL_STOP_TIMEOUT_MS } from './model-keys.mjs';
@@ -40,6 +40,7 @@ import { instanceSettings } from '../../organization/src/instance-settings.mjs';
import { organizationWriter, OrganizationError, setReplyLimits } from '../../organization/src/organization.mjs';
import { definitionVerbs, DEFINITION_BUS_VERBS } from '../../organization/src/definition-verbs.mjs';
import { ORG_PREFIX, orgDefinitionName, compositionOf, readTemplate, entryFromTemplate, lineDiff, PRIMITIVES } from '../../organization/src/definitions.mjs';
import { SYSTEM_ONLY_REFUSAL, systemOnly } from '../../organization/src/vocabulary.mjs';
import { installedStarterPacks, readSavedTemplate } from '../../plugins/src/starter-pack.mjs';
import { TemplateError, templateList, templatePreview, templateSave } from '../../organization/src/template-save.mjs';
import { checkComposition } from '../../organization/src/composition.mjs';
@@ -300,7 +301,7 @@ const COPY_SWEEP_MS = 60000;
const PACK_AS = /^(definitions|workflows)\.([a-z0-9][a-z0-9._-]{0,63})=([a-z0-9][a-z0-9._-]{0,63})$/;
const SAVED_PREFIX = 'saved:';
// Each op, and whether it writes.
const PACK_OPS = Object.freeze({ packs: false, 'pack.preview': false, 'pack.apply': true, 'board.set': true, 'workflow.set': true });
const PACK_OPS = Object.freeze({ packs: false, 'pack.preview': false, 'pack.state': false, 'pack.apply': true, 'board.set': true, 'workflow.set': true });
const EMPTY_CHIEF = Object.freeze({ tools: [], network: 'none', authority: { withinRole: [], crossRole: [] }, credentials: [] });
function packOps({ writer, rolesDir, dataRoot, system, registryFor, assertClean, configDir }) {
const bad = () => { throw new BusError('invalid-request'); };
@@ -313,7 +314,10 @@ function packOps({ writer, rolesDir, dataRoot, system, registryFor, assertClean,
async function loadPack(name, actor) {
if (typeof name !== 'string' || name.length > 128) bad();
if (name.startsWith(SAVED_PREFIX)) return readSavedTemplate({ configDir, account: actor, name: name.slice(SAVED_PREFIX.length), rolesDir });
const found = (await installed()).find(p => p.id === name);
const { packs, refused } = await installedStarterPacks({ dataRoot, rolesDir });
const found = packs.find(p => p.id === name);
// #1873 triage-fence: an installed pack refused for naming a system-only template says so.
if (!found && refused.some(r => r.name === name && r.code === SYSTEM_ONLY_REFUSAL)) throw new BusError(SYSTEM_ONLY_REFUSAL);
if (!found) throw new BusError('starter-pack-not-found');
return found;
}
@@ -332,6 +336,9 @@ function packOps({ writer, rolesDir, dataRoot, system, registryFor, assertClean,
// The entry a pack definition writes: a template reference becomes the template's own entry, pinned
// by its hash (a moved hash refuses), and a full entry is copied as it is. Neither carries rev.
function entryOf(value) {
// #1873 triage-fence: preview and apply both refuse a pack naming a system-only template, as a
// reference or as the from of a full entry.
if (systemOnly(value?.template) || systemOnly(value?.from?.template)) throw new BusError(SYSTEM_ONLY_REFUSAL);
if (Object.hasOwn(value, 'template') && Object.hasOwn(value, 'sha256') && Object.keys(value).length === 2) {
const template = readTemplate(rolesDir, value.template);
if (template.sha256 !== value.sha256) throw new BusError('starter-pack-template-changed');
@@ -501,9 +508,67 @@ function packOps({ writer, rolesDir, dataRoot, system, registryFor, assertClean,
return `projects.${args.project}.${key}`;
};
const revisionOf = args => { if (typeof args.revision !== 'string' || !/^[0-9a-f]{64}$/.test(args.revision)) bad(); return args.revision; };
// Ruling 2026-11-14 ("If I choose a starter pack and apply it, that is a decision!"): the
// organization facts the broker's pack hire loop and the packs read need, as the file stands.
// `pack` names a packs entry the way apply names the pack: saved:NAME is the owner's saved
// template, any other name the latest shipped or installed entry of that id. The route is a
// resolved harness, model and thinking (system, organization and agent vars): the chief's (the
// launch.by instance), else the org assistant's (lane pr2, lead ruling 2026-11-14), else null.
// routeFrom names which one gave it.
const latestEntries = doc => {
const latest = new Map();
for (const e of doc.packs ?? []) if (isObject(e) && typeof e.id === 'string') latest.set(canonicalJson([e.id, e.origin ?? null, e.project ?? null]), e);
return [...latest.values()];
};
const agentsOf = doc => {
const launched = doc.launch?.instances ?? [];
const one = (entry, isLaunched) => ({ hireDecision: typeof entry?.hireDecision === 'string' ? entry.hireDecision : null, launched: isLaunched });
return {
org: Object.fromEntries(Object.entries(doc.roles ?? {}).map(([name, e]) => [name, one(e, launched.includes(name))])),
projects: Object.fromEntries(Object.entries(doc.projects ?? {}).filter(([, p]) => isObject(p) && p.kind !== 'library')
.map(([project, p]) => [project, Object.fromEntries(Object.entries(p.agents ?? {}).map(([name, e]) => [name, one(e, true)]))])),
};
};
// The org assistant is the instance whose definition is `assistant` (broker.mjs continuationEffect);
// with several, the one named `assistant`, else the first in key order.
const packRoute = (doc, id) => {
const roles = doc.roles ?? {};
let loaded = null;
const routeOf = instance => {
loaded ??= validateBusinessDocument(doc, `${id}.json`, { rolesDir, dataRoot });
const { vars } = resolveInstance({ system, business: loaded, instance });
const pick = k => (typeof vars?.[k] === 'string' && vars[k] ? vars[k] : null);
if (!pick('harness') || !pick('model')) return null;
return { harness: pick('harness'), model: pick('model'), ...(pick('thinking') ? { thinking: pick('thinking') } : {}) };
};
const by = doc.launch?.by;
const chief = typeof by === 'string' && Object.hasOwn(roles, by) ? routeOf(by) : null;
if (chief) return { route: chief, routeFrom: 'chief' };
const assistants = Object.keys(roles).filter(name => isObject(roles[name]) && roles[name].definition === 'assistant');
const assistant = assistants.includes('assistant') ? 'assistant' : assistants[0];
const route = assistant === undefined ? null : routeOf(assistant);
return route ? { route, routeFrom: 'assistant' } : { route: null, routeFrom: null };
};
const applied = doc => latestEntries(doc).map(e => ({ id: e.id, origin: e.origin ?? null, project: e.project ?? null, version: e.version ?? null,
proposedHires: (Array.isArray(e.proposedHires) ? e.proposedHires : []).filter(isObject).map(h => ({ name: h.name, reason: h.reason ?? null })) }));
return {
// Shipped and installed packs only: a saved template is its owner's, read by name.
packs: async () => ({ packs: (await installed()).map(({ id, origin, pack }) => ({ id, origin, pack })) }),
// Shipped and installed packs only: a saved template is its owner's, read by name. `applied` is
// the latest packs entry of each id, origin and project, and `agents` each instance's hire record.
packs: async (id) => {
const doc = writer.read(id).document;
return { packs: (await installed()).map(({ id: pid, origin, pack }) => ({ id: pid, origin, pack })), applied: applied(doc), agents: agentsOf(doc) };
},
'pack.state': (id, args) => {
if (typeof args.pack !== 'string' || !args.pack) bad();
const project = args.project ?? null;
if (project !== null && (typeof project !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(project))) bad();
const { document: doc, revision } = writer.read(id);
const saved = args.pack.startsWith(SAVED_PREFIX);
const packId = saved ? args.pack.slice(SAVED_PREFIX.length) : args.pack;
const entry = (doc.packs ?? []).filter(e => isObject(e) && e.id === packId && (e.project ?? null) === project && (saved ? e.origin === 'saved' : e.origin !== 'saved')).at(-1) ?? null;
const scope = project === null ? doc.roles ?? {} : doc.projects?.[project]?.agents ?? {};
return { revision, entry: entry ? structuredClone(entry) : null, ...packRoute(doc, id), names: Object.keys(scope), noHire: [...(doc.launch?.noHire ?? [])] };
},
'pack.preview': (id, args, actor, context) => build(id, args, actor, context),
'pack.apply': async (id, args, actor, context) => {
if (typeof args.digest !== 'string') bad();
@@ -566,6 +631,7 @@ export async function startBroker({
builtinBinding = null,
modelCatalogue = null, // in-process fixture seam; boot JSON cannot supply a service
makeProviderLoader = createLoader, // in-process fixture seam; boot JSON cannot supply a function
initProxy = initializeProxy, // in-process fixture seam (a test install pin); boot JSON cannot supply a function
// #1873 A3: the boot's root and project agent copies (cli config.mjs copiesAtBoot), plain data. Every
// reload of the organization file below re-applies this snapshot, never the root file.
copies = null,
@@ -573,6 +639,7 @@ export async function startBroker({
// In-process only, like librarySync; production passes none.
copyTransport = null,
}) {
if (typeof initProxy !== 'function') throw new BusError('invalid-host-request');
if (copies !== null && (typeof copies !== 'object' || Array.isArray(copies) || typeof copies.org !== 'string'
|| !Object.hasOwn(businesses ?? {}, copies.org) || copies.copies === null || typeof copies.copies !== 'object' || Array.isArray(copies.copies)))
throw new BusError('invalid-host-request');
@@ -770,7 +837,72 @@ export async function startBroker({
// records. A daily key quota moved within one agent's lineage keeps its since and its count.
const keyLineage=(business,keyId)=>modelKeyLineage(credentials.status(),business,keyId);
const settings=organization?launchSettings({...organization,sessions:()=>readSessions(dataRoot),levels,keyLineage}):null;
modelCatalogues = modelCatalogue ?? (settings ? createModelCatalogue({ pluginDataRoot:instanceRoot ?? dataRoot, client: () => modelProxyClient, settings: id => settings.current(id).plugins ?? {}, proxyLock }) : null);
// #1873 proxy-pickup: a bus started before the instance had a shared proxy picks it up at the
// first request that needs one, through the start path's checks, loader and lock. A client got
// that way (or by this bus's own proxy.init) is checked again at every such request and dropped
// when the start path would now refuse it. A bus started with a proxy keeps its boot client:
// its ModelKeys holds that client. `proxyCause` is the one plain line the owner sees while there
// is no client: static text and a refusal code, never a path or a key.
let lateProxy = false, proxyCause = null, proxySync = Promise.resolve();
const dropLateProxy = cause => {
if (lateProxy) { modelProxyClient = null; proxyPage = null; proxyPort = null; proxyLock = null; lateProxy = false; modelCatalogues?.invalidate?.(); }
proxyCause = cause;
};
// The host refuses fixture-proxy-configured at boot when a dev fixture is recorded for the
// instance and the organization routes a launch to the fixture (cli dev-fixture.mjs
// fixtureLauncherOptions). Anything but a plain absence of the record counts as recorded.
const fixtureRecorded = () => { try { lstatSync(join(instanceRoot ?? dataRoot, 'dev-fixture', 'fixture.json')); return true; } catch (error) { return error.code !== 'ENOENT'; } };
const usesFixture = id => {
try {
const doc = settings.current(id), providers = doc.plugins?.['model-provider'];
return (Array.isArray(providers) && providers.includes('fixture')) || Object.values(doc.launch?.models ?? {}).some(m => m?.module === 'fixture');
} catch { return true; }
};
async function pickProxy() {
if (proxy || !organization || !settings) return;
if (org !== null && (!org || typeof org.id !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(org.id) || typeof instanceDataRoot !== 'string' || typeof instanceConfigDir !== 'string'))
return dropLateProxy('This bus has no valid organization binding for the shared proxy (invalid-host-request). Restart it from the host.');
const configDir = org ? instanceConfigDir : organization.dir;
let found;
try { found = loadProxy(configDir, instanceRoot ?? dataRoot); }
catch (error) { return dropLateProxy(`The model proxy settings do not load (${/^proxy-[a-z-]+$/.test(error?.code ?? '') ? error.code : 'proxy-config-invalid'}). This organization reads no accounts or catalogue until they do.`); }
if (found === undefined) return dropLateProxy('The model proxy has not been set up for this instance yet. Set it up on the Model proxy page.');
if (modelProxyClient && found.port !== proxyPort) dropLateProxy(null);
if (fixtureRecorded() && Object.keys(businesses).some(usesFixture))
return dropLateProxy('This organization routes launches to the dev fixture, which the host refuses next to a model proxy (fixture-proxy-configured). Remove the fixture or stop using it here.');
let client;
try { client = await loadManagementClient({ configDir, proxy: found, receipt: proxyReceipt }); }
catch { return dropLateProxy('The model proxy management key does not load (proxy-management-key-invalid). This bus cannot reach the proxy until the key file is fixed.'); }
let lock = null;
if (org) {
try { lock = createProxyLock({ stateDir: join(instanceDataRoot, 'proxy'), identity: `${instanceConfigDir}:${found.port}` }); }
catch { return dropLateProxy('The shared proxy lock does not load (proxy-lock-invalid). Check the proxy state for this instance, then restart this bus.'); }
}
proxyCause = null;
// Same port, key and lock still load: keep the client and its page, which holds login states.
if (modelProxyClient) return;
modelProxyClient = client; proxyPort = found.port; proxyLock = lock; lateProxy = true;
configureProxyPage(); modelCatalogues?.invalidate?.();
}
// One check at a time; an unexpected failure drops a late client, never keeps it.
const syncProxy = () => (proxySync = proxySync.then(pickProxy).catch(() => dropLateProxy('The model proxy could not be checked (proxy-down). Try again shortly.')));
// Unavailable with no client: the catalogue names the cause instead of a bare unavailable.
// pickup-launch: a late client serves accounts and the catalogue, but a launch on it needs what
// only the start path builds (ModelKeys here, the proxy in the host launcher's boot system), so
// while this bus holds one a ready catalogue says plainly that a restart is needed. Not on an
// unavailable one: a fence, a collision or a down proxy still refuses after a restart.
const RESTART_TO_LAUNCH = 'Restart this organization to start agents on these models.';
const explainCatalogue = value => {
if (value?.status === 'unavailable' && value.reason === undefined && !modelProxyClient && proxyCause)
return { ...value, reason: 'proxy-not-configured', notices: [proxyCause] };
if (lateProxy && value?.status === 'ready')
return { ...value, notices: [...(value?.notices ?? []), RESTART_TO_LAUNCH] };
return value;
};
const baseCatalogue = settings ? createModelCatalogue({ pluginDataRoot:instanceRoot ?? dataRoot, client: () => modelProxyClient, settings: id => settings.current(id).plugins ?? {},
// A view, so a lock taken by a later pickup or init counts as it does for the start path's.
proxyLock: { assertCertain: () => proxyLock?.assertCertain(), generation: () => proxyLock?.generation() } }) : null;
modelCatalogues = modelCatalogue ?? (baseCatalogue ? { ...baseCatalogue, read: async (id, options) => { await syncProxy(); return explainCatalogue(await baseCatalogue.read(id, options)); } } : null);
// Resolve legacy table entries with the enabled modules' declarations. A
// missing or ambiguous mapping never becomes an available route.
async function catalogueFor(id, options = {}) {
@@ -1275,22 +1407,27 @@ export async function startBroker({
// Row 199 (#1697, design section 6): issue, rotate, revoke and delete, live with no restart; each
// rewrites or records through the organization writer, so changes.jsonl holds the receipt.
proxyPage: async (verb, args, scope) => {
if (!proxyPage) throw new BusError('not-configured');
await syncProxy();
if (!proxyPage) throw new BusError('not-configured', proxyCause ?? undefined);
return proxyPage.request(verb, args, scope);
},
proxyInit: organization ? async args => {
const settings = await initializeProxy({ configDir: organization.dir, dataRoot: instanceRoot ?? dataRoot, ...args });
modelProxyClient = await loadManagementClient({ configDir: organization.dir, proxy: settings, receipt: proxyReceipt });
proxyPort = settings.port;
const settings = await initProxy({ configDir: organization.dir, dataRoot: instanceRoot ?? dataRoot, ...args });
const client = await loadManagementClient({ configDir: organization.dir, proxy: settings, receipt: proxyReceipt });
// #1873: an org bus that initializes the shared proxy also holds its write lock from now on.
if (org && !proxyLock) proxyLock = createProxyLock({ stateDir: join(instanceDataRoot, 'proxy'), identity: `${instanceConfigDir}:${settings.port}` });
configureProxyPage();
// proxy-pickup: the lock comes first, so a lock that refuses leaves no client behind.
const lock = org && !proxyLock ? createProxyLock({ stateDir: join(instanceDataRoot, 'proxy'), identity: `${instanceConfigDir}:${settings.port}` }) : proxyLock;
// proxy-pickup: a client this bus did not boot with is checked again like a picked-up one.
if (!proxy) { lateProxy = true; proxyCause = null; }
modelProxyClient = client; proxyPort = settings.port; proxyLock = lock;
configureProxyPage(); modelCatalogues?.invalidate?.();
return settings;
} : null,
// #1873: clear the uncertain-write fence only on restart evidence this host re-proves: the
// process on the proxy port is new, alive and started after the fence was set.
proxyFenceClear: organization ? async ({ evidence }) => {
if (!proxyLock || !modelProxyClient) throw new BusError('not-configured');
await syncProxy();
if (!proxyLock || !modelProxyClient) throw new BusError('not-configured', proxyCause ?? undefined);
return proxyLock.clear({ restarted: true, read: () => modelProxyClient.getKeys(), verify: previous => verifyRestart(evidence, { fence: previous, port: proxyPort }) });
} : null,
credentialVerbs: organization
+3 -2
View File
@@ -15,7 +15,7 @@ if (!process.env.MOSAIC_BUS_TESTER_NONCE) {
// P19 #876: only the re-executed child, whose initial environment holds the nonce, talks to the
// bus. Loading the client (and the broker module graph behind it) here instead of at the top
// keeps the re-exec parent to a bare node start.
const { Client } = await import('./client.mjs');
const { Client, NOT_SENT_EXIT } = await import('./client.mjs');
const { readProcess } = await import('./human.mjs');
try {
const request = JSON.parse(readFileSync(0, 'utf8'));
@@ -39,5 +39,6 @@ try {
process.stdout.write(JSON.stringify(result) + '\n');
} catch (e) {
process.stderr.write((/^[a-z-]{1,64}$/.test(e.code ?? '') ? e.code : 'invalid-request') + '\n');
process.exitCode = 2;
// E2E6 fix 6: as human-cli.mjs, a request that never left exits NOT_SENT_EXIT.
process.exitCode = e?.notSent === true ? NOT_SENT_EXIT : 2;
}
@@ -64,7 +64,7 @@ test('AU authority reverse crossing deadline in prepared IO never publishes',asy
});
test('AU authority resolver rechecks budget removal after a proposal was raised',async t=>{
const f=world(t),d=await f.raise(),b=structuredClone(f.loaded());b.plugins['limit-check']=[];f.broker.reloadBusiness('demo',b);
const before=f.writer.read('demo').revision;await assert.rejects(f.call('judge','decision.resolve',{id:d.id,choice:'yes'}),{code:'autonomy-precondition'});
const before=f.writer.read('demo').revision;await assert.rejects(f.call('judge','decision.resolve',{id:d.id,choice:'yes'}),{code:'autonomy-precondition',reason:'no enforced budget covers new agents; authority away from the loop needs one'});
assert.equal(f.writer.read('demo').revision,before);assert.equal(f.store.get('SELECT count(*) n FROM decision_events WHERE decision=?',d.id).n,0);
});
@@ -113,7 +113,7 @@ test('AU an account-quota authority raise routes to the resolver only when the h
const covered=world(t,{account:true,countsAccount:name=>name==='pi'}),d=await covered.raise();assert.equal(d.route_to,'judge');
for(const countsAccount of [undefined,()=>false,()=>null]){
const f=world(t,{account:true,countsAccount});
await assert.rejects(f.raise(),{code:'autonomy-precondition'});
await assert.rejects(f.raise(),{code:'autonomy-precondition',reason:'no enforced budget covers new agents; authority away from the loop needs one'});
assert.equal(f.store.get("SELECT count(*) n FROM decisions").n,0);
}
});
+12 -4
View File
@@ -137,11 +137,11 @@ test('AU authority near requires an enforced organization budget covering every
const f=await settingsFixture(t);
for(const tokens of [{},{instances:{coder:tokenCap}},{providers:{unrelated:tokenCap}}]){
f.business.launch.limits.tokens=tokens;f.broker.reloadBusiness('demo',f.business);
await assert.rejects(f.set(authorityNear),{code:'autonomy-precondition'});
await assert.rejects(f.set(authorityNear),{code:'autonomy-precondition',reason:'no enforced budget covers new agents; authority away from the loop needs one'});
}
f.business.launch.limits.tokens={providers:{anthropic:{...tokenCap,limit:0}}};
f.business.plugins={'limit-check':[]};f.broker.reloadBusiness('demo',f.business);
await assert.rejects(f.set(authorityNear),{code:'autonomy-precondition'});
await assert.rejects(f.set(authorityNear),{code:'autonomy-precondition',reason:'no enforced budget covers new agents; authority away from the loop needs one'});
f.business.plugins={'limit-check':['token-limit']};f.broker.reloadBusiness('demo',f.business);
await f.set(authorityNear);assert.equal(f.writes(),1);
});
@@ -153,12 +153,20 @@ test('AU authority out refuses until per-definition agent limits exist, even wit
await assert.rejects(f.set({...authorityNear,authority:'out of the loop'}),e=>e.code==='authority-limits-unavailable' && /near the loop/.test(e.nextStep));
assert.equal(f.writes(),1);
});
test('AU a class moves out of the loop only from near the loop, and the refusal says so (E2E6 fix 7)',async t=>{
const f=await settingsFixture(t);await f.set({'cross-role':'in the loop'});
await assert.rejects(f.set({'cross-role':'out of the loop',notices:true}),{code:'autonomy-precondition',reason:'cross-role moves out of the loop only from near the loop'});
assert.equal(f.writes(),1);
});
test('AU moving out requires an actual near resolution and a later owner review',async t=>{
const f=await settingsFixture(t);await f.set({merge:'in the loop'});await f.set({merge:'near the loop',notices:true});
// E2E6 fix 7: each refusal names the check that failed.
await assert.rejects(f.set({merge:'near the loop'}),{code:'autonomy-precondition',reason:'owner notices are off; a class near the loop needs them on'});
await assert.rejects(f.set({merge:'out of the loop',notices:true}),{code:'autonomy-precondition',reason:'merge needs your review of its trail since the last autonomy change'});
f.call(f.owner,'autonomy.review.console',{decisionClass:'merge'});
await assert.rejects(f.set({merge:'out of the loop',notices:true}),{code:'autonomy-precondition'});
await assert.rejects(f.set({merge:'out of the loop',notices:true}),{code:'autonomy-precondition',reason:'merge needs a near-loop decision since the last autonomy change, and your trail review after it'});
const d=f.raise({action:'git.merge.protected'});f.call(f.chief,'decision.resolve',{id:d.id,choice:'yes'});
await assert.rejects(f.set({merge:'out of the loop',notices:true}),{code:'autonomy-precondition'});
await assert.rejects(f.set({merge:'out of the loop',notices:true}),{code:'autonomy-precondition',reason:'merge needs a near-loop decision since the last autonomy change, and your trail review after it'});
f.call(f.owner,'autonomy.review.console',{decisionClass:'merge'});
await f.set({merge:'out of the loop',notices:true});
});
+7 -3
View File
@@ -11,6 +11,8 @@
// which shares humanCall's spawn as transport(). The human proof and its spawn are unchanged.
// Row 225 (C2-10b) re-pins webui bus.mjs for one STATUS entry, library-revert-not-agent: 409; no proof
// or transport change.
// E2E6 fix 6 re-pins human-cli.mjs, which exits 5 when its connect failed before the request was
// written, and cli transport.mjs, which reads that exit as bus-not-running. The proof is unchanged.
import test from "node:test";
import assert from "node:assert/strict";
import { createHash } from "node:crypto";
@@ -21,9 +23,10 @@ import { Client } from "../src/client.mjs";
const baselines = {
"packages/bus/src/human.mjs": "bb13c146717cdc46d75d157177e400edac4d3e10f14fe511027a25fd44cec885",
"packages/bus/src/human-cli.mjs": "271b9781d73cf31cc562a56180e3ebcd725b5fde148a83347a201fdef2fc28af",
"packages/bus/src/human-cli.mjs": "410892787cc70440b0ba4c45d6f24861d12ee5e70cba678cfeb1ed86b796c149",
// Row 239 (#1745): EXIT outcome-unknown-revoked 1; no proof or transport change.
"packages/cli/src/transport.mjs": "662642a8ce739fcb6c188ad07125a94e008c8a305eced127c8041d472c56e55b",
// E2E6 fix 6: shim exit 5 with outcome-unknown becomes bus-not-running (exit 3, start and recover next).
"packages/cli/src/transport.mjs": "101870f7ffb47a9cbd54ebd8c1901734cc9f442d6770cb2a0d059afd4d14b160",
// Row 165 (#1662): seven STATUS entries for the role instance routes (organization-instance-exists,
// organization-unknown-instance, organization-credentials-out-of-scope, organization-launch-not-configured,
// organization-no-change, organization-project-mismatch, organization-unresolvable-instance), no proof or
@@ -39,7 +42,8 @@ const baselines = {
// deadline; userCall shares transport(). Nonces, argv and limits are unchanged.
// #1873 A3: STATUS maps credential-unbound, copy-refused, project-refused and project-agent-elsewhere
// to 409; no proof or transport change.
"packages/webui/src/bus.mjs": "d8f3e0eb5299fdb192e98a1238ca693aae7c36af9a21de72d5f5d39610589377",
// #1873 triage-fence: STATUS maps template-system-only to 400; no proof or transport change.
"packages/webui/src/bus.mjs": "cd08e1beb49e9e881bb1b308f2ab3343a480b47dd9b17ccbd16e120d341d7511",
};
const repoFile = path => new URL("../../../" + path, import.meta.url);
+1 -1
View File
@@ -89,7 +89,7 @@ function setup(t) {
// #797 / #1839 adds the owner-only artifact read to the existing decision and request controls;
// no unsuffixed verb is ever a console verb.
test('N4: owner Console verbs have an explicit immutable whitelist and exclude decision.resolve', () => {
assert.deepEqual([...CONSOLE_VERBS], ['project.remote.get.console', 'project.remote.set.console', 'autonomy.get.console', 'autonomy.set.console', 'autonomy.review.console', 'decision.confirm.console', 'decision.reverse.console', 'request.workspace.console', 'request.artifact.console', 'decision.preview.console', 'decision.resolve.console', 'hire.preview.console', 'hire.resolve.console', 'hire.start.console', 'hire.templates.console', 'prd.revoke.console', 'request.mode.console', 'request.draft.console',
assert.deepEqual([...CONSOLE_VERBS], ['project.remote.get.console', 'project.remote.set.console', 'autonomy.get.console', 'autonomy.set.console', 'autonomy.review.console', 'decision.confirm.console', 'decision.reverse.console', 'request.workspace.console', 'request.artifact.console', 'decision.preview.console', 'decision.resolve.console', 'hire.preview.console', 'hire.resolve.console', 'hire.start.console', 'hire.templates.console', 'pack.hire.console', 'prd.revoke.console', 'request.mode.console', 'request.draft.console',
'request.get.console', 'request.projects.console', 'request.answer.console', 'request.attach.console', 'request.cancel.console',
// Starter packs SP4 (#1873): the owner's pack list and preview, and the three pack writes.
'packs.console', 'pack.preview.console', 'pack.apply.console', 'board.set.console', 'workflow.set.console',
+26 -2
View File
@@ -11,7 +11,7 @@ import { tmpdir } from 'node:os';
import { createHash, randomBytes } from 'node:crypto';
import { Credentials } from '../src/credentials.mjs';
import { ManagementClient } from '../../model-proxy/src/client.mjs';
import { ModelKeys, REVOKE_TIMEOUT_MS, REVOKE_POLL_MS } from '../src/model-keys.mjs';
import { ModelKeys, REVOKE_TIMEOUT_MS, REVOKE_POLL_MS, ISSUE_PROBE_TIMEOUT_MS, ISSUE_REPROBE_MIN_MS } from '../src/model-keys.mjs';
import { startBroker } from '../src/runtime.mjs';
import { busOrganization } from '../src/organization-context.mjs';
import { Registry } from '../../seat/src/session.mjs';
@@ -42,6 +42,7 @@ async function fixture(t, { delayed = 0 } = {}) {
const key = req.headers.authorization?.slice(7);
const accepted = state.keys.includes(key) || (state.removed.has(key) && performance.now() - state.removed.get(key) < state.delay);
state.onProbe?.(state.status ?? (accepted ? 200 : 401));
if (state.stallProbe?.()) return;
res.writeHead(state.status ?? (accepted ? 200 : 401)); res.end('{}');
});
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
@@ -123,10 +124,33 @@ test('proxy-revoke-revision-conflict keeps local revoking record and ids-only re
assert.equal(JSON.stringify(f.receipts).includes(key), false);
await f.create().reconcile(); assert.equal(f.credentials.modelRecord('demo/coder') === null, true);
});
for (const status of [401, 503, 302]) test(`proxy-key-refused: preflight rejects HTTP ${status} with exactly one probe`, async t => {
for (const status of [503, 302]) test(`proxy-key-refused: preflight rejects HTTP ${status} with exactly one probe`, async t => {
const f = await fixture(t); await f.manager.reconcile(); await f.manager.ensure('demo/coder'); f.state.status = status;
await assert.rejects(f.manager.preflight('demo/coder'), failCode('proxy-key-refused')); assert.equal(f.state.probes, 1);
});
test('proxy-key-refused: a key that keeps answering 401 refuses once the short probe deadline passes', async t => {
const f = await fixture(t); await f.manager.reconcile(); await f.manager.ensure('demo/coder'); f.state.status = 401;
const started = performance.now();
await assert.rejects(f.manager.preflight('demo/coder'), failCode('proxy-key-refused'));
const took = performance.now() - started;
assert.ok(f.state.probes > 1, 'a 401 is probed again'); assert.ok(took >= ISSUE_PROBE_TIMEOUT_MS && took < ISSUE_PROBE_TIMEOUT_MS + 2000, `bounded: ${took}`);
});
test('proxy-down: a re-probe that stalls ends near the probe deadline, not the client default', async t => {
const f = await fixture(t); await f.manager.reconcile(); await f.manager.ensure('demo/coder'); f.state.status = 401;
f.state.stallProbe = () => f.state.probes >= 2;
const started = performance.now();
await assert.rejects(f.manager.preflight('demo/coder'), failCode('proxy-down'));
const took = performance.now() - started;
assert.equal(f.state.probes, 2); assert.ok(took < ISSUE_PROBE_TIMEOUT_MS + ISSUE_REPROBE_MIN_MS + 1000, `bounded: ${took}`);
});
// Every v8 CLIProxyAPI applies the PUT by an async reload; on 8.0.79 a just-issued key answers 401
// past the confirming GET (#1873).
test('first launch passes when the proxy applies the new key a moment after the PUT answers', async t => {
const f = await fixture(t); await f.manager.reconcile(); f.state.status = 401;
f.state.onProbe = () => { if (f.state.probes === 3) f.state.status = null; };
const answer = await f.manager.preflight('demo/coder');
assert.equal(f.state.probes, 3); assert.equal(f.state.keys.includes(answer.key), true);
});
test('rotate keeps old key while its run lives, new launches use new, exit removes old', async t => {
const f = await fixture(t); await f.manager.reconcile(); const first = await f.manager.ensure('demo/coder');
f.runs.push({ instance: 'demo/coder', run: 'old', keyId: hash(first.key) });
+367
View File
@@ -0,0 +1,367 @@
// Ruling 2026-11-14 ("If I choose a starter pack and apply it, that is a decision!"): a person's
// apply records one hire decision per proposed hire in the same act and applies it, so the agents
// exist when the call returns. The owner approves every line; a member with org.hire gets the
// unflagged hires and the rest wait in the owner's inbox; an agent's apply never hires.
import test from 'node:test';
import assert from 'node:assert/strict';
import { chmodSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { DatabaseSync } from 'node:sqlite';
import { pluginHash } from '../../plugins/src/pinned.mjs';
import { installPlugin } from '../../plugins/src/install.mjs';
import { starterPack as codingPack } from '../../plugins/starter-pack/coding/index.mjs';
import { templateHash } from '../../organization/src/definitions.mjs';
const SUBJECT = { provider: 'test', iss: 'test', sub: 'owner' };
const ROUTE = { harness: 'pi', model: 'claude-opus-5-5' };
const ASSISTANT_ROUTE = { harness: 'pi', model: 'glm-5.3-flash', thinking: 'low' };
// assistant: false, no assistant instance; {} an assistant with no vars; any other object the
// assistant's vars. Lane pr2: a pack hire falls back to the org assistant's route.
async function harness(t, { route = true, assistant = false, mutate = () => {} } = {}) {
const { startBroker } = await import('../src/runtime.mjs');
const { businessDoc, rolesCopy, systemFor, writeJson } = await import('../../organization/tests/helpers.mjs');
const root = mkdtempSync(join(tmpdir(), 'packhire-'));
const rolesDir = rolesCopy(root);
const doc = businessDoc(root, 'demo');
doc.plugins = { harness: ['pi'] };
if (route) doc.roles.chief.vars = { ...ROUTE };
if (assistant) doc.roles.assistant = { definition: 'assistant', ...(Object.keys(assistant).length ? { vars: { ...assistant } } : {}) };
mutate(doc);
writeJson(join(root, 'businesses/demo.json'), doc);
const data = join(root, 'data');
mkdirSync(data, { mode: 0o700 });
const roles = { chief: { definition: 'chief-of-staff', authority: { withinRole: ['decision.resolve.technical', 'decision.resolve.delivery', 'organization.change'], crossRole: [] } },
coder: { definition: 'coder', authority: { withinRole: ['message.send'], crossRole: [] } } };
const businesses = { demo: { id: 'demo', human: 'jason', arbiters: { technical: 'chief', delivery: 'chief' }, roles } };
const bus = await startBroker({ dataRoot: data, businesses, organization: { dir: root, rolesDir, system: systemFor(root) } });
const thaw = (p) => { const st = lstatSync(p); if (st.isSymbolicLink()) return; if (st.isDirectory()) { chmodSync(p, 0o700); for (const e of readdirSync(p)) thaw(join(p, e)); } };
t.after(async () => { await bus.close(); thaw(root); rmSync(root, { recursive: true, force: true }); });
const b = bus.broker;
const consoleOwner = b.bindConsole({ business: 'demo', human: 'jason', subject: SUBJECT });
const human = b.bindHuman({ business: 'demo', human: 'jason', via: 'cli', outsideAgent: true });
const member = b.bindHireConsole({ business: 'demo', actor: 'alice', subject: { provider: 'test', iss: 'test', sub: 'alice' }, rights: ['org.hire', 'board.read'] });
const call = async (verb, args = {}, cap = consoleOwner) => b.request(cap, { verb, args });
const path = join(root, 'businesses/demo.json');
const file = () => JSON.parse(readFileSync(path, 'utf8'));
const decisions = list => b.request(human, { verb: 'decisions', args: { list } });
// The broker's own database, read-only.
const db = (sql, ...a) => { const d = new DatabaseSync(join(data, 'bus/bus.sqlite'), { readOnly: true }); try { return d.prepare(sql).all(...a); } finally { d.close(); } };
const store = { all: db, get: (sql, ...a) => db(sql, ...a)[0] };
const events = () => store.all("SELECT kind, body FROM events WHERE business='demo' ORDER BY seq").map(r => ({ kind: r.kind, body: JSON.parse(r.body) }));
let n = 0;
const install = (pack) => {
const src = join(root, `src-${n++}`);
mkdirSync(join(src, 'starter-pack'), { recursive: true });
writeFileSync(join(src, 'starter-pack', 'index.mjs'), `export const interfaceVersion = 1;\nexport function starterPack() { return ${JSON.stringify(pack)}; }\n`);
const manifest = { name: pack.id, version: '1.0.0', kinds: ['starter-pack'], interfaceVersions: { 'starter-pack': 1 }, sha256: '0'.repeat(64),
source: { path: 'fixture', version: '1.0.0' }, signature: null, tools: [], actions: [], services: [], roleTemplates: [] };
writeFileSync(join(src, 'plugin.json'), JSON.stringify(manifest));
manifest.sha256 = pluginHash(src);
writeFileSync(join(src, 'plugin.json'), JSON.stringify(manifest));
installPlugin({ dataRoot: data, source: src, expectedHash: manifest.sha256 });
};
const op = (name) => events().filter(e => e.kind === 'action.allowed' && e.body.operation === name).map(e => e.body);
return { bus, b, root, rolesDir, path, consoleOwner, human, member, call, file, decisions, events, op, store, install };
}
const apply = async (call, args = { pack: 'coding' }, cap) => {
const preview = await call('pack.preview.console', args, cap);
return { preview, out: await call('pack.apply.console', { ...args, digest: preview.digest }, cap) };
};
// The evidence an inbox-approved hire leaves: a decision.raise naming the hire, a console
// resolution yes, a hire.consume and a hire.apply, and the instance's hireDecision.
function assertHireRecord(h, name, decision) {
const raise = h.op('decision.raise').find(r => r.decision === decision);
assert.ok(raise, `decision.raise for ${name}`);
assert.equal(raise.hire.name, name);
assert.equal(raise.action, 'role.hire');
assert.ok(h.op('hire.consume').some(r => r.decision === decision), `hire.consume for ${name}`);
assert.ok(h.op('hire.apply').some(r => r.decision === decision), `hire.apply for ${name}`);
const resolved = h.store.all('SELECT op, choice, via, by FROM decision_events WHERE decision=?', decision);
assert.deepEqual(resolved.map(r => [r.op, r.choice]), [['resolved', 'yes']]);
assert.equal(h.file().roles[name].hireDecision, decision);
}
test('PD the owner applies a pack with flagged hires on a fresh org; the agents exist on return, each with its decision record', async t => {
const h = await harness(t);
const { preview, out } = await apply(h.call);
// The preview lists the flagged and credential lines the owner's apply approves.
assert.ok(preview.hires.some(x => x.flagged.length || x.credentialLines.length), JSON.stringify(preview.hires));
assert.deepEqual(out.hires.map(x => [x.name, x.state]), [['pm-1', 'hired'], ['coder-1', 'hired'], ['reviewer-1', 'hired']]);
const doc = h.file();
for (const x of out.hires) {
assert.ok(Object.hasOwn(doc.roles, x.name), `${x.name} exists`);
assert.ok(doc.launch.instances.includes(x.name), `${x.name} is launched`);
assertHireRecord(h, x.name, x.decision);
}
// The coder's credential lines are approved, not bound: the instance is written with no credential.
assert.equal(doc.roles['coder-1'].credentials, undefined);
// Each hire names its pack.
assert.deepEqual(h.op('pack.hire').map(e => [e.hire, e.pack, e.origin, e.project]), out.hires.map(x => [x.name, 'coding', 'shipped', null]));
// The instances read carries the pack each agent came from.
const inst = await h.call('instances', {}, h.human);
assert.deepEqual(inst.instances['coder-1'].pack, { id: 'coding', origin: 'shipped', project: null });
assert.equal(inst.instances.pm.pack, undefined);
// The packs read counts the hires and lists nothing open.
const packs = await h.call('packs.console');
const applied = packs.applied.find(a => a.id === 'coding');
assert.deepEqual(applied.hired.sort(), ['coder-1', 'pm-1', 'reviewer-1']);
assert.deepEqual(applied.open, []);
});
test('PD a re-apply hires nothing twice', async t => {
const h = await harness(t);
await apply(h.call);
const raised = h.op('decision.raise').length;
const again = await apply(h.call);
// The second apply proposes nothing: each proposal's instance exists.
assert.deepEqual(again.out.hires, []);
assert.deepEqual((await h.call('packs.console')).applied.find(a => a.id === 'coding').hired.sort(), ['coder-1', 'pm-1', 'reviewer-1']);
// The pack action on the same entry skips each instance that exists.
const hired = await h.call('pack.hire.console', { pack: 'coding' });
assert.equal(h.op('decision.raise').length, raised);
assert.ok(hired.hires.every(x => x.state === 'exists'), JSON.stringify(hired));
});
test('PD the owner CLI apply hires through the same path, resolved via cli', async t => {
const h = await harness(t);
const preview = await h.call('pack.preview', { pack: 'coding' }, h.human);
const out = await h.call('pack.apply', { pack: 'coding', digest: preview.digest }, h.human);
assert.deepEqual(out.hires.map(x => x.state), ['hired', 'hired', 'hired']);
for (const x of out.hires) {
assertHireRecord(h, x.name, x.decision);
assert.equal(h.store.get('SELECT via FROM decision_events WHERE decision=?', x.decision).via, 'cli');
assert.equal(h.store.get('SELECT raised_by_run FROM decisions WHERE id=?', x.decision).raised_by_run, 'human-cli');
}
});
test('PD with no chief route the apply records the pack, hires nothing and says why; the hire action on the existing record hires once a route exists', async t => {
const h = await harness(t, { route: false });
const { out } = await apply(h.call);
assert.deepEqual(out.hires.map(x => [x.name, x.state, x.code]), [['pm-1', 'refused', 'pack-hire-route-missing'], ['coder-1', 'refused', 'pack-hire-route-missing'], ['reviewer-1', 'refused', 'pack-hire-route-missing']]);
assert.equal(h.op('decision.raise').length, 0);
const packs = await h.call('packs.console');
assert.deepEqual(packs.applied.find(a => a.id === 'coding').open.map(o => [o.name, o.state, o.code, typeof o.reason]),
[['pm-1', 'refused', 'pack-hire-route-missing', 'string'], ['coder-1', 'refused', 'pack-hire-route-missing', 'string'], ['reviewer-1', 'refused', 'pack-hire-route-missing', 'string']]);
// The owner gives the chief a route; the pack action hires from the packs entry already recorded.
const doc = h.file();
doc.roles.chief.vars = { ...ROUTE };
writeFileSync(h.path, JSON.stringify(doc, null, 2) + '\n');
const hired = await h.call('pack.hire.console', { pack: 'coding' });
assert.deepEqual(hired.hires.map(x => [x.name, x.state]), [['pm-1', 'hired'], ['coder-1', 'hired'], ['reviewer-1', 'hired']]);
for (const x of hired.hires) assertHireRecord(h, x.name, x.decision);
assert.deepEqual((await h.call('packs.console')).applied.find(a => a.id === 'coding').open, []);
// The CLI's pack hire is the same action; nothing is left to hire.
const cli = await h.call('pack.hire', { pack: 'coding' }, h.human);
assert.ok(cli.hires.every(x => x.state === 'exists'));
await assert.rejects(h.call('pack.hire.console', { pack: 'nosuch' }), /pack-not-applied/);
});
// A pack with one hire inside the chief's own grants and two above them.
// An installed pack's own definition narrows a template; the scout keeps only read.
const mixkit = (rolesDir) => {
const SCOUT = { from: { template: 'coder', sha256: templateHash(rolesDir, 'coder') }, role: { tools: ['read'], network: 'none', authority: { withinRole: [], crossRole: [] }, credentials: [] }, instructions: 'Read and report.' };
const p = structuredClone(codingPack());
p.id = 'mixkit';
p.definitions = { scout: SCOUT, coder: p.definitions.coder, reviewer: p.definitions.reviewer };
p.hires = [{ name: 'scout-1', definition: 'scout', reason: 'reads and reports' }, { name: 'coder-1', definition: 'coder', reason: 'implements each change' }, { name: 'reviewer-1', definition: 'reviewer', reason: 'reviews each change' }];
p.workflows = { change: { description: 'One change.', steps: [{ id: 'build', title: 'Build it', roles: ['coder'], state: 'in-progress' }, { id: 'review', title: 'Review it', roles: ['reviewer'], state: 'in-review' }] } };
return p;
};
test('PD a member with org.hire gets the unflagged hires; the flagged ones become open decisions in the owner inbox', async t => {
const h = await harness(t, { route: false });
h.install(mixkit(h.rolesDir));
await apply(h.call, { pack: 'mixkit' });
const doc = h.file();
doc.roles.chief.vars = { ...ROUTE };
writeFileSync(h.path, JSON.stringify(doc, null, 2) + '\n');
const out = await h.call('pack.hire.console', { pack: 'mixkit' }, h.member);
assert.deepEqual(out.hires.map(x => [x.name, x.state]), [['scout-1', 'hired'], ['coder-1', 'awaiting-owner'], ['reviewer-1', 'awaiting-owner']]);
const after = h.file();
assert.ok(after.launch.instances.includes('scout-1'));
assert.equal(Object.hasOwn(after.roles, 'coder-1'), false);
assert.equal(Object.hasOwn(after.roles, 'reviewer-1'), false);
assertHireRecord(h, 'scout-1', out.hires[0].decision);
assert.equal(h.store.get('SELECT via FROM decision_events WHERE decision=?', out.hires[0].decision).via, 'console');
// Each flagged hire is an open decision routed to the human, raised by the member's act.
const waiting = out.hires.filter(x => x.state === 'awaiting-owner');
for (const x of waiting) {
const d = h.store.get('SELECT route_to, raised_by_role, action FROM decisions WHERE id=?', x.decision);
assert.deepEqual([d.route_to, d.raised_by_role, d.action], ['human', 'human', 'role.hire']);
assert.equal(h.store.all('SELECT 1 FROM decision_events WHERE decision=?', x.decision).length, 0);
}
// The packs read lists both as open, awaiting the owner, each with the pack's reason.
const applied = (await h.call('packs.console')).applied.find(a => a.id === 'mixkit');
assert.deepEqual(applied.hired, ['scout-1']);
assert.deepEqual(applied.open.map(o => [o.name, o.state, o.reason, o.decision]), [['coder-1', 'awaiting-owner', 'implements each change', waiting[0].decision], ['reviewer-1', 'awaiting-owner', 'reviews each change', waiting[1].decision]]);
// The member's pack action never re-raises a hire an open decision names.
const again = await h.call('pack.hire.console', { pack: 'mixkit' }, h.member);
assert.deepEqual(again.hires.map(x => [x.name, x.state, x.decision ?? null]), [['scout-1', 'exists', null], ['coder-1', 'open', waiting[0].decision], ['reviewer-1', 'open', waiting[1].decision]]);
// The member cannot approve a flagged hire; the owner can, from the inbox, and the agent exists.
const view = await h.call('hire.preview.console', { id: waiting[0].decision });
await assert.rejects(h.call('hire.resolve.console', { id: waiting[0].decision, choice: 'yes', digest: view.digest }, h.member), /hire-owner-required|human-required/);
await h.call('hire.resolve.console', { id: waiting[0].decision, choice: 'yes', digest: view.digest });
assert.ok(h.file().launch.instances.includes('coder-1'));
// The owner's pack action approves the rest: the open pack decision is withdrawn by the owner and
// replaced by one approved in the same act.
const owner = await h.call('pack.hire.console', { pack: 'mixkit' });
assert.deepEqual(owner.hires.map(x => [x.name, x.state, x.supersedes ?? null]), [['scout-1', 'exists', null], ['coder-1', 'exists', null], ['reviewer-1', 'hired', waiting[1].decision]]);
assert.deepEqual(h.store.all('SELECT op, by FROM decision_events WHERE decision=?', waiting[1].decision).map(r => [r.op, r.by]), [['withdrawn', 'jason']]);
assertHireRecord(h, 'reviewer-1', owner.hires[2].decision);
const done = (await h.call('packs.console')).applied.find(a => a.id === 'mixkit');
assert.deepEqual(done.hired.sort(), ['coder-1', 'reviewer-1', 'scout-1']);
assert.deepEqual(done.open, []);
});
test('PD an agent apply still refuses human-required and hires nothing; the tester and a cli cap on the console name refuse', async t => {
const h = await harness(t);
const agent = h.b.bindLaunch({ business: 'demo', role: 'coder', run: 'coder-run', harness: 'pi', address: 'coder-run' });
h.b.request(agent, { verb: 'role.claim' });
assert.throws(() => h.b.request(agent, { verb: 'pack.apply.console', args: { pack: 'coding', digest: 'a'.repeat(64) } }), /human-required/);
await assert.rejects(Promise.resolve().then(() => h.b.request(agent, { verb: 'pack.hire', args: { pack: 'coding' } })), /human-required/);
await assert.rejects(Promise.resolve().then(() => h.b.request(agent, { verb: 'pack.hire.console', args: { pack: 'coding' } })), /human-required/);
await assert.rejects(Promise.resolve().then(() => h.b.request(h.human, { verb: 'pack.hire.console', args: { pack: 'coding' } })), /human-required/);
await assert.rejects(h.call('pack.hire', { pack: 'coding' }), /human-required/);
for (const args of [{}, { pack: 7 }, { pack: 'coding', extra: 1 }, { pack: 'coding', project: 'Bad Name' }])
await assert.rejects(h.call('pack.hire.console', args), /invalid-request/);
assert.equal(h.op('decision.raise').length, 0);
});
test('PD a project pack hires into projects.<p>.agents', async t => {
const h = await harness(t);
const pack = structuredClone(codingPack());
pack.id = 'projkit'; pack.scope = 'project';
h.install(pack);
const { out } = await apply(h.call, { pack: 'projkit', project: 'stack' });
assert.deepEqual(out.hires.map(x => x.state), ['hired', 'hired', 'hired']);
const agents = h.file().projects.stack.agents;
for (const x of out.hires) { assert.equal(agents[x.name].hireDecision, x.decision); assert.equal(agents[x.name].credentials, undefined); }
assert.equal(Object.hasOwn(h.file().roles, 'coder-1'), false);
assert.deepEqual(h.op('pack.hire').map(e => e.project), ['stack', 'stack', 'stack']);
const applied = (await h.call('packs.console')).applied.find(a => a.id === 'projkit');
assert.deepEqual(applied.hired.sort(), ['coder-1', 'pm-1', 'reviewer-1']);
const again = await h.call('pack.hire.console', { pack: 'projkit', project: 'stack' });
assert.ok(again.hires.every(x => x.state === 'exists'));
});
test('PD the new codes are in the refusal table with a rail and a next step that names no path', async () => {
const { REFUSALS } = await import('../src/refusals.mjs');
for (const c of ['pack-not-applied', 'pack-hire-route-missing', 'hire-owner-required', 'no-chief-of-staff']) {
assert.ok(Object.hasOwn(REFUSALS, c), c);
assert.ok(REFUSALS[c].rail?.length > 5);
assert.ok(REFUSALS[c].nextStep?.length > 20);
assert.ok(!/(^|[\s("'`])(\/|~\/)/.test(REFUSALS[c].nextStep));
}
});
test('PD the owner supersede withdraws an inbox decision only after its replacement hires; a refused replacement leaves it open', async t => {
const h = await harness(t, { route: false });
h.install(mixkit(h.rolesDir));
await apply(h.call, { pack: 'mixkit' });
const setRoute = (vars) => { const doc = h.file(); if (vars) doc.roles.chief.vars = { ...vars }; else delete doc.roles.chief.vars; writeFileSync(h.path, JSON.stringify(doc, null, 2) + '\n'); };
setRoute(ROUTE);
const out = await h.call('pack.hire.console', { pack: 'mixkit' }, h.member);
const waiting = out.hires.filter(x => x.state === 'awaiting-owner');
assert.equal(waiting.length, 2);
// The packs read marks each member-raised line as raised by a pack hire.
const open = (await h.call('packs.console')).applied.find(a => a.id === 'mixkit').open;
assert.deepEqual(open.map(o => [o.name, o.state, o.fromPack]), [['coder-1', 'awaiting-owner', true], ['reviewer-1', 'awaiting-owner', true]]);
// The chief loses its route; the owner's pack hire cannot build a replacement.
setRoute(null);
const owner = await h.call('pack.hire.console', { pack: 'mixkit' });
assert.deepEqual(owner.hires.map(x => [x.name, x.state, x.code ?? null]), [['scout-1', 'exists', null], ['coder-1', 'refused', 'pack-hire-route-missing'], ['reviewer-1', 'refused', 'pack-hire-route-missing']]);
// Both inbox decisions are still open: nothing withdrew them.
for (const x of waiting) assert.deepEqual(h.store.all('SELECT op FROM decision_events WHERE decision=?', x.decision), []);
// With the route back, the owner's pack hire replaces them, withdrawing each only once its replacement applied.
setRoute(ROUTE);
const done = await h.call('pack.hire.console', { pack: 'mixkit' });
assert.deepEqual(done.hires.map(x => [x.name, x.state, x.supersedes ?? null]), [['scout-1', 'exists', null], ['coder-1', 'hired', waiting[0].decision], ['reviewer-1', 'hired', waiting[1].decision]]);
for (const x of waiting) assert.deepEqual(h.store.all('SELECT op, by FROM decision_events WHERE decision=?', x.decision).map(r => [r.op, r.by]), [['withdrawn', 'jason']]);
});
test('PD a second pack hire on the same organization while one runs refuses organization-busy and raises nothing', async t => {
const h = await harness(t, { route: false });
await apply(h.call);
const doc = h.file();
doc.roles.chief.vars = { ...ROUTE };
writeFileSync(h.path, JSON.stringify(doc, null, 2) + '\n');
const first = h.call('pack.hire.console', { pack: 'coding' });
const second = h.call('pack.hire.console', { pack: 'coding' });
await assert.rejects(second, /organization-busy/);
const hired = await first;
assert.deepEqual(hired.hires.map(x => [x.name, x.state]), [['pm-1', 'hired'], ['coder-1', 'hired'], ['reviewer-1', 'hired']]);
// One decision per hire: the refused call raised nothing.
assert.equal(h.op('decision.raise').length, 3);
// Once the loop ends the latch is free again: the next pack hire runs and finds nothing to hire.
const later = await h.call('pack.hire.console', { pack: 'coding' });
assert.ok(later.hires.every(x => x.state === 'exists'), JSON.stringify(later));
});
// Lane pr2 (lead ruling 2026-11-14): a pack hire takes the chief of staff's harness and model, else
// the org assistant's, else refuses pack-hire-route-missing.
test('PR2 with no chief route the apply hires every proposal with the org assistant harness and model', async t => {
const h = await harness(t, { route: false, assistant: ASSISTANT_ROUTE });
const { out } = await apply(h.call);
assert.deepEqual(out.hires.map(x => [x.name, x.state, x.routeFrom]), [['pm-1', 'hired', 'assistant'], ['coder-1', 'hired', 'assistant'], ['reviewer-1', 'hired', 'assistant']]);
const doc = h.file();
for (const x of out.hires) {
assertHireRecord(h, x.name, x.decision);
assert.deepEqual(doc.roles[x.name].vars, ASSISTANT_ROUTE);
assert.deepEqual(h.op('decision.raise').find(r => r.decision === x.decision).hire.route, ASSISTANT_ROUTE);
}
});
test('PR2 a chief route wins over a different assistant route', async t => {
const h = await harness(t, { assistant: ASSISTANT_ROUTE });
const { out } = await apply(h.call);
assert.deepEqual(out.hires.map(x => [x.name, x.state, x.routeFrom]), [['pm-1', 'hired', 'chief'], ['coder-1', 'hired', 'chief'], ['reviewer-1', 'hired', 'chief']]);
for (const x of out.hires) assert.deepEqual(h.file().roles[x.name].vars, ROUTE);
});
test('PR2 an assistant with no harness and model gives no route: the apply refuses as before', async t => {
for (const assistant of [{}, { harness: 'pi' }]) {
const h = await harness(t, { route: false, assistant });
const { out } = await apply(h.call);
assert.deepEqual(out.hires.map(x => [x.name, x.state, x.code]), [['pm-1', 'refused', 'pack-hire-route-missing'], ['coder-1', 'refused', 'pack-hire-route-missing'], ['reviewer-1', 'refused', 'pack-hire-route-missing']]);
assert.equal(h.op('decision.raise').length, 0);
}
});
test('PR2 with several assistants the one named assistant gives the route, else the first in key order', async t => {
const OTHER = { harness: 'pi', model: 'claude-sonnet-5-5' };
const named = await harness(t, { route: false, assistant: ASSISTANT_ROUTE, mutate: doc => { doc.roles = { aide: { definition: 'assistant', vars: { ...OTHER } }, ...doc.roles }; } });
const a = await apply(named.call);
for (const x of a.out.hires) assert.deepEqual(named.file().roles[x.name].vars, ASSISTANT_ROUTE);
const first = await harness(t, { route: false, mutate: doc => { doc.roles.aide = { definition: 'assistant', vars: { ...OTHER } }; doc.roles.zed = { definition: 'assistant', vars: { ...ASSISTANT_ROUTE } }; } });
const b = await apply(first.call);
assert.deepEqual(b.out.hires.map(x => [x.state, x.routeFrom]), [['hired', 'assistant'], ['hired', 'assistant'], ['hired', 'assistant']]);
for (const x of b.out.hires) assert.deepEqual(first.file().roles[x.name].vars, OTHER);
});
test('PR2 a member pack hire on the assistant route marks hired and awaiting-owner lines routeFrom assistant', async t => {
const h = await harness(t, { route: false, assistant: ASSISTANT_ROUTE });
h.install(mixkit(h.rolesDir));
// The member's apply would not run; the owner's apply would hire everything. Record the pack first
// with the assistant route absent, then give it back and let the member hire.
const doc0 = h.file(); delete doc0.roles.assistant.vars; writeFileSync(h.path, JSON.stringify(doc0, null, 2) + '\n');
await apply(h.call, { pack: 'mixkit' });
const doc = h.file(); doc.roles.assistant.vars = { ...ASSISTANT_ROUTE }; writeFileSync(h.path, JSON.stringify(doc, null, 2) + '\n');
const out = await h.call('pack.hire.console', { pack: 'mixkit' }, h.member);
assert.deepEqual(out.hires.map(x => [x.name, x.state, x.routeFrom]), [['scout-1', 'hired', 'assistant'], ['coder-1', 'awaiting-owner', 'assistant'], ['reviewer-1', 'awaiting-owner', 'assistant']]);
assert.deepEqual(h.file().roles['scout-1'].vars, ASSISTANT_ROUTE);
});
test('PR2 a project pack with no chief route hires into the project on the assistant route', async t => {
const h = await harness(t, { route: false, assistant: ASSISTANT_ROUTE });
const pack = structuredClone(codingPack());
pack.id = 'projkit'; pack.scope = 'project';
h.install(pack);
const { out } = await apply(h.call, { pack: 'projkit', project: 'stack' });
assert.deepEqual(out.hires.map(x => [x.state, x.routeFrom]), [['hired', 'assistant'], ['hired', 'assistant'], ['hired', 'assistant']]);
const agents = h.file().projects.stack.agents;
for (const x of out.hires) { assert.equal(agents[x.name].hireDecision, x.decision); assert.deepEqual(h.op('decision.raise').find(r => r.decision === x.decision).hire.route, ASSISTANT_ROUTE); }
});
+299
View File
@@ -0,0 +1,299 @@
// #1873 pickup-launch: a bus that picked up the shared proxy late serves accounts and a ready
// catalogue, but a launch on a proxy model still needs a restart (no ModelKeys on the bus, no proxy
// in the host launcher's boot system). While it holds such a client, its catalogue answer says so
// in one plain notice, and a launch refuses exactly as before. A refused or dropped client shows
// its cause instead. Real buses, a real launcher whose model ops go to the bus, a fake loopback
// management server; no live config.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import http from 'node:http';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { createHash, randomBytes } from 'node:crypto';
import { pathToFileURL } from 'node:url';
import { startBroker } from '../src/runtime.mjs';
import { busOrganization } from '../src/organization-context.mjs';
import { createProxyLock } from '../src/proxy-lock.mjs';
import { Registry, launchLogFile } from '../../seat/src/session.mjs';
import { loadBusiness } from '../../organization/src/organization-config.mjs';
import { resolveInstance } from '../../organization/src/resolve.mjs';
import { businessDoc, rolesCopy, systemFor, writeJson } from '../../organization/tests/helpers.mjs';
import { PIN } from '../../model-proxy/src/common.mjs';
import { initializeProxy, installPaths, loadProxy } from '../../model-proxy/src/settings.mjs';
import { createLauncher } from '../../cli/src/launcher.mjs';
import { initializeControl } from '../../processing-control/src/state.mjs';
import { ZAI_URL } from '../../plugins/model-provider/cliproxy/index.mjs';
import { fakeHarnesses, humanEnv, withoutHostCredentials } from '../../cli/tests/helpers.mjs';
import { REPO_SKILLS } from '../../harness/tests/helpers.mjs';
const RESTART = 'Restart this organization to start agents on these models.';
const MODEL = 'claude-claude-opus-5-5';
const sha = value => createHash('sha256').update(value).digest('hex');
// A loopback stand-in for the proxy's management API: one ready Claude account with one model,
// and an access key list that keeps what a PUT sends, so a boot ModelKeys reconciles against it.
async function fakeProxy(t, key, port = 0, { groups = [] } = {}) {
const seen = { calls: 0, wrongKey: 0 };
let accessKeys = [];
const server = http.createServer((req, res) => {
seen.calls++;
if (req.headers.authorization !== `Bearer ${key}`) { seen.wrongKey++; res.writeHead(401); res.end('{}'); return; }
const url = new URL(req.url, 'http://127.0.0.1');
if (url.pathname === '/v8/management/config/access/api-keys' && req.method === 'PUT') {
const chunks = [];
req.on('data', c => chunks.push(c));
req.on('end', () => { accessKeys = JSON.parse(Buffer.concat(chunks)); res.end(JSON.stringify({ status: 'ok' })); });
return;
}
const answer = url.pathname === '/v8/management/credentials' ? { files: [{ id: 'acct-1', name: 'acct-1', provider: 'claude', status: 'ready', priority: 1 }] }
: url.pathname === '/v8/management/credentials/models' ? { models: [{ id: 'claude-opus-5-5' }] }
: url.pathname === '/v8/management/config/api-keys/claude' ? groups
: url.pathname === '/v8/management/config/access/api-keys' ? accessKeys
: null;
if (answer === null) { res.writeHead(404); res.end('{}'); return; }
res.end(JSON.stringify(answer));
});
await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, '127.0.0.1', resolve); });
t.after(async () => { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); });
return { port: server.address().port, seen, server };
}
// One instance (config dir + data root) and a fake proxy install whose bytes a test pin names.
function instance(t) {
const root = fs.mkdtempSync(join(tmpdir(), 'pl-'));
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
const configDir = join(root, 'config'), dataRoot = join(root, 'instance');
fs.mkdirSync(join(configDir, 'secrets', 'agents'), { recursive: true, mode: 0o700 });
fs.chmodSync(join(configDir, 'secrets'), 0o700);
fs.mkdirSync(dataRoot, { mode: 0o700 });
const paths = installPaths(dataRoot);
fs.mkdirSync(join(paths.dir, 'static'), { recursive: true, mode: 0o700 });
fs.writeFileSync(paths.binary, 'fixture proxy binary\n', { mode: 0o700 });
fs.writeFileSync(paths.panel, '<!doctype html>\n', { mode: 0o600 });
const pin = { ...PIN, binary: { ...PIN.binary, sha256: sha('fixture proxy binary\n') }, panel: { ...PIN.panel, sha256: sha('<!doctype html>\n') } };
const rolesDir = rolesCopy(root), system = systemFor(root);
const key = `pl1873-${randomBytes(24).toString('hex')}`;
return { root, configDir, dataRoot, paths, pin, rolesDir, system, key };
}
// A real organization bus on the instance, started with no proxy unless `binding.proxy` gives one.
async function orgBus(t, f, id, { providers = ['cliproxy'], binding = {} } = {}) {
const doc = businessDoc(f.root, id);
doc.plugins = { harness: ['pi'], 'model-provider': providers };
writeJson(join(f.configDir, 'businesses', `${id}.json`), doc);
const business = loadBusiness(id, { dir: f.configDir, rolesDir: f.rolesDir }), resolved = {};
for (const name of Object.keys(business.roles)) resolved[name] = resolveInstance({ system: f.system, business, instance: name });
const dataRoot = join(f.root, `${id}-bus`); fs.mkdirSync(dataRoot, { mode: 0o700 }); new Registry(dataRoot);
const bus = await startBroker({ dataRoot, businesses: { [id]: busOrganization(business, resolved) },
organization: { dir: f.configDir, rolesDir: f.rolesDir, system: f.system },
instanceRoot: f.dataRoot, org: { id }, instanceDataRoot: f.dataRoot, instanceConfigDir: f.configDir,
initProxy: args => initializeProxy({ ...args, pin: f.pin }), ...binding });
t.after(() => bus.close().catch(() => {}));
const human = bus.broker.bindHuman({ business: id, human: 'jason', via: 'cli', outsideAgent: true });
const ask = (verb, args) => Promise.resolve().then(() => bus.broker.request(human, { verb, args }));
return { id, bus, ask, dataRoot };
}
// Every stderr line written while `run` is in flight.
async function capture(run) {
const write = process.stderr.write, lines = [];
process.stderr.write = (chunk, ...rest) => { lines.push(String(chunk)); return write.call(process.stderr, chunk, ...rest); };
try { return { value: await run(), lines }; } finally { process.stderr.write = write; }
}
async function initThroughA(t, f, a, options) {
const settings = await a.ask('proxy.init', { key: f.key });
const proxy = await fakeProxy(t, f.key, settings.port, options);
return { settings, proxy };
}
// The owner picks the catalogue's proxy model for the coder on the Routing page, through the bus.
async function pickModel(o) {
const view = await o.ask('routes');
assert.equal(view.catalogue.status, 'ready');
assert.ok(view.catalogue.models.some(m => m.key === MODEL));
await o.ask('routes.set', { revision: view.revision, routes: { coder: { harness: 'pi', model: MODEL, thinking: 'low', fallback: null } } });
}
// The host launcher as cli.mjs builds it for a bus that booted with no proxy.json: its system has
// no proxy. The model ops go to the bus itself; the rest are the launch-routes stub, and
// authorizeLaunch stops a launch that passed every check before it.
async function hostLauncher(t, f, o, { system = {} } = {}) {
initializeControl(o.dataRoot);
// A launch whose role names a skill that is not enabled refuses before the model gate.
if (!fs.existsSync(join(f.dataRoot, 'skills-enabled'))) fs.cpSync(REPO_SKILLS, join(f.dataRoot, 'skills-enabled'), { recursive: true });
const env = withoutHostCredentials(humanEnv({ MOSAIC_CONFIG: join(f.configDir, 'config.json'), MOSAIC_ROLES_DIR: f.rolesDir }), { piKey: true });
const answers = [], ops = [];
const host = { business: o.id, beforeClose: () => {}, op: async m => {
ops.push(m.op);
if (m.op === 'identity') return { business: o.id, role: 'pm' };
if (m.op === 'mayLaunch') return { allow: true };
if (m.op === 'modelAdmission' || m.op === 'modelPreflight') { const answer = await o.bus[m.op](m); answers.push({ op: m.op, answer }); return answer; }
if (m.op === 'authorizeLaunch') throw Object.assign(Error('fixture authorization stop'), { code: 'fixture-policy' });
return {};
} };
const cliproxy = JSON.stringify(pathToFileURL(new URL('../../plugins/model-provider/cliproxy/index.mjs', import.meta.url).pathname).href);
const makeLoader = await fakeHarnesses(t, { pi: null }, write => write('model-provider', 'cliproxy', `export * from ${cliproxy};\n`));
// The validated system config shape (mosaic-config.mjs), as cli.mjs passes it with the org root.
const config = { configVersion: 1, environment: 'development', dataRoot: o.dataRoot, instanceRoot: f.dataRoot,
execution: { backend: 'docker', provider: 'zai', model: 'glm-5.3-flash', adapter: 'mock' }, ...system };
const launcher = createLauncher({ host, system: config, env, makeLoader, bwrap: '/usr/bin/true', log: () => {} });
t.after(() => launcher.close?.().catch?.(() => {}));
const events = () => { try { return fs.readFileSync(launchLogFile(o.dataRoot, o.id), 'utf8').trim().split('\n').filter(Boolean).map(l => JSON.parse(l)); } catch { return []; } };
return { launch: () => launcher.fromSession('fixture-cap', 'coder'), answers, ops, events };
}
const restartNotices = view => view.catalogue.notices.filter(n => n === RESTART).length;
test('a bus that picked up the proxy says on its ready catalogue that a restart starts agents on these models, and the launch refuses as before', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
const before = await b.ask('routes');
assert.equal(before.catalogue.status, 'unavailable');
assert.equal(restartNotices(before), 0, 'no client yet: the not-set-up cause, not the restart notice');
await initThroughA(t, f, a);
await pickModel(b);
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'ready');
assert.equal(restartNotices(view), 1);
assert.equal(restartNotices(await b.ask('routes')), 1, 'one notice at every read');
// The bus that ran init holds a client it did not boot with too.
const own = await a.ask('routes');
assert.equal(own.catalogue.status, 'ready');
assert.equal(restartNotices(own), 1);
// The launch refuses as before, with the existing code and line, before any key or run: the
// launcher booted with no proxy sends no proxy transport, and the bus's admission refuses that.
const host = await hostLauncher(t, f, b);
assert.deepEqual(await host.launch(), { ok: false, error: 'model-provider-unavailable' });
assert.deepEqual(host.answers, [{ op: 'modelAdmission', answer: { allow: false, code: 'model-provider-unavailable' } }]);
assert.equal(host.ops.includes('authorizeLaunch'), false);
assert.equal(host.ops.includes('modelPreflight'), false);
const refused = host.events().filter(e => e.event === 'refused');
assert.equal(refused.length, 1);
assert.equal(refused[0].code, 'model-provider-unavailable');
assert.equal(refused[0].why, 'model cliproxy/claude/claude-opus-5-5 unavailable (model-provider-unavailable)');
// The bus side has no ModelKeys: a preflight issues no key.
assert.equal(await b.bus.modelPreflight({ business: 'beta', role: 'coder' }), null);
});
test('the restart notice is added after the notices the catalogue already carries', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
// A z.ai upstream group with no models: the cliproxy catalogue's own notice.
await initThroughA(t, f, a, { groups: [{ 'base-url': ZAI_URL, keys: [{ name: 'group-1' }] }] });
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'ready');
assert.deepEqual(view.catalogue.notices, ['z.ai account has no models configured. Add them on Model proxy.', RESTART]);
});
test('a bus started with the proxy shows no restart notice', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha');
await initThroughA(t, f, a);
const c = await orgBus(t, f, 'gamma', { binding: { proxy: loadProxy(f.configDir, f.dataRoot) } });
const view = await c.ask('routes');
assert.equal(view.catalogue.status, 'ready', JSON.stringify(view.catalogue));
assert.deepEqual(view.catalogue.notices, []);
});
test('an organization with no model provider shows a disabled catalogue with no restart notice (the routes verb answers disabled itself)', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta', { providers: [] });
await initThroughA(t, f, a);
await b.ask('proxy.accounts', {});
assert.ok(b.bus.modelProxy, 'the client is held');
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'disabled');
assert.deepEqual(view.catalogue.notices, []);
});
test('a fenced catalogue on a picked-up client reads unavailable with no restart notice, since a restart would not help', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
const { proxy } = await initThroughA(t, f, a);
assert.equal(restartNotices(await b.ask('routes')), 1);
createProxyLock({ stateDir: join(f.dataRoot, 'proxy'), identity: `${f.configDir}:${proxy.port}` }).fence({ org: 'alpha' });
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.ok(b.bus.modelProxy);
assert.equal(restartNotices(view), 0);
// A bus that booted with the proxy on the same fenced instance, which is what a restart gives,
// reads the same unavailable catalogue: the restart notice would have sent the owner nowhere.
const c = await orgBus(t, f, 'gamma', { binding: { proxy: loadProxy(f.configDir, f.dataRoot) } });
assert.equal((await c.ask('routes')).catalogue.status, 'unavailable');
// Once the fence is gone, the ready catalogue says again that a restart is needed.
fs.rmSync(join(f.dataRoot, 'proxy', 'mosaic-keys.uncertain'));
const after = await b.ask('routes');
assert.equal(after.catalogue.status, 'ready', JSON.stringify(after.catalogue));
assert.equal(restartNotices(after), 1);
});
test('refused settings still refuse the launch and name their cause, not the restart notice', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
await pickModel(b);
// The management key file stops being private: the start path refuses it.
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o644);
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.equal(view.catalogue.reason, 'proxy-not-configured');
assert.equal(view.catalogue.notices.length, 1);
assert.match(view.catalogue.notices[0], /management key does not load/);
assert.equal(b.bus.modelProxy, null);
const host = await hostLauncher(t, f, b);
// The bus itself refuses now: the catalogue keeps the model it saw, marked unavailable.
assert.deepEqual(await host.launch(), { ok: false, error: 'model-provider-unavailable' });
assert.deepEqual(host.answers, [{ op: 'modelAdmission', answer: { allow: false, code: 'model-provider-unavailable' } }]);
assert.match(host.events().at(-1).why, /^model cliproxy\/claude\/claude-opus-5-5 unavailable \(model-provider-unavailable\)$/);
});
test('a dropped client refuses the next launch, and the catalogue names the cause instead of the restart notice', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
await pickModel(b);
const host = await hostLauncher(t, f, b);
assert.deepEqual(await host.launch(), { ok: false, error: 'model-provider-unavailable' });
assert.equal(restartNotices(await b.ask('routes')), 1);
fs.rmSync(join(f.configDir, 'proxy.json'));
// The next launch refuses with the same code and line.
assert.deepEqual(await host.launch(), { ok: false, error: 'model-provider-unavailable' });
assert.deepEqual(host.answers.map(a => a.answer), [{ allow: false, code: 'model-provider-unavailable' }, { allow: false, code: 'model-provider-unavailable' }]);
assert.equal(host.events().filter(e => e.event === 'refused').length, 2);
// The page's next read drops the client and names the cause.
const view = await b.ask('routes');
assert.equal(b.bus.modelProxy, null);
assert.equal(view.catalogue.status, 'unavailable');
assert.equal(view.catalogue.reason, 'proxy-not-configured');
assert.deepEqual(view.catalogue.notices.length, 1);
assert.match(view.catalogue.notices[0], /not been set up/);
});
test('the management key is in no stderr line, response, refusal, launch log or file the launch path writes', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
await pickModel(b);
const host = await hostLauncher(t, f, b);
const outputs = [];
const { lines } = await capture(async () => {
outputs.push(await b.ask('routes'));
outputs.push(await host.launch());
outputs.push(await b.bus.modelPreflight({ business: 'beta', role: 'coder' }));
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o644);
outputs.push(await b.ask('routes'));
outputs.push(await host.launch());
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o600);
outputs.push(await b.ask('routes'));
outputs.push(await host.launch());
});
outputs.push(host.answers, host.events());
assert.equal(lines.join('').includes(f.key), false, 'stderr');
assert.equal(JSON.stringify(outputs).includes(f.key), false, 'responses, answers and launch log');
const walk = dir => fs.readdirSync(dir, { withFileTypes: true }).flatMap(e => e.isDirectory() ? walk(join(dir, e.name)) : e.isFile() ? [join(dir, e.name)] : []);
const files = [...walk(b.dataRoot), ...walk(join(f.dataRoot, 'proxy')).filter(p => !p.endsWith('/config.yaml'))];
assert.ok(files.some(p => p === launchLogFile(b.dataRoot, 'beta')), 'the launch log is scanned');
for (const file of files) assert.equal(fs.readFileSync(file).includes(f.key), false, file);
});
+2 -1
View File
@@ -43,7 +43,8 @@ test('Broker keeps the sandbox client import closure: only the listed imports, n
// Row 236 (#1742, #436b) reads giteaName and parseGiteaUrl for the Gitea grant path.
// FED R3 r5 (row 274, #414) reads covers, a user's grant check, from it.
// Row 219 reads THREAD_DEFINITIONS from the same vocabulary for creative thread admission.
"import { pluginName, ID_PATTERN, THREAD_DEFINITIONS, END_PROTECTED, forkProblem, forkUrl, credentialKind, validArgv, commandAllowed, HOST_ID, CREATIVE_DEFINITIONS, giteaName, parseGiteaUrl, covers, grantScopeOf, grantInScope } from '../../organization/src/vocabulary.mjs';",
// #1873 triage-fence reads SYSTEM_ONLY_REFUSAL and systemOnly from the same vocabulary.
"import { pluginName, ID_PATTERN, THREAD_DEFINITIONS, END_PROTECTED, forkProblem, forkUrl, credentialKind, validArgv, commandAllowed, HOST_ID, CREATIVE_DEFINITIONS, giteaName, parseGiteaUrl, covers, grantScopeOf, grantInScope, SYSTEM_ONLY_REFUSAL, systemOnly } from '../../organization/src/vocabulary.mjs';",
]);
assert.doesNotMatch(source, /\bimport\s*\(/);
assert.doesNotMatch(readFileSync(new URL('../src/proxy-page-vocabulary.mjs', import.meta.url), 'utf8'), /\bimport\b/);
+371
View File
@@ -0,0 +1,371 @@
// #1873 proxy-pickup: a running organization bus picks up the shared model proxy that another
// organization's bus initialized, with no restart, through the start path's loader and lock. A
// bus whose proxy settings the start path would refuse still refuses, and names the cause in one
// plain line. Real buses and a fake loopback management server; no live config.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import http from 'node:http';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { createHash, randomBytes } from 'node:crypto';
import { startBroker } from '../src/runtime.mjs';
import { busOrganization } from '../src/organization-context.mjs';
import { createProxyLock } from '../src/proxy-lock.mjs';
import { Registry } from '../../seat/src/session.mjs';
import { loadBusiness } from '../../organization/src/organization-config.mjs';
import { resolveInstance } from '../../organization/src/resolve.mjs';
import { businessDoc, rolesCopy, systemFor, writeJson } from '../../organization/tests/helpers.mjs';
import { PIN } from '../../model-proxy/src/common.mjs';
import { initializeProxy, installPaths } from '../../model-proxy/src/settings.mjs';
import { FIXTURE_ENTRY, FIXTURE_KEY_NAME } from '../../plugins/model-provider/fixture/index.mjs';
const sha = value => createHash('sha256').update(value).digest('hex');
// A loopback stand-in for the proxy's management API: one ready Claude account with one model.
async function fakeProxy(t, key, port = 0) {
const seen = { calls: 0, wrongKey: 0 };
const server = http.createServer((req, res) => {
seen.calls++;
if (req.headers.authorization !== `Bearer ${key}`) { seen.wrongKey++; res.writeHead(401); res.end('{}'); return; }
const url = new URL(req.url, 'http://127.0.0.1');
const answer = url.pathname === '/v8/management/credentials' ? { files: [{ id: 'acct-1', name: 'acct-1', provider: 'claude', status: 'ready', priority: 1 }] }
: url.pathname === '/v8/management/credentials/models' ? { models: [{ id: 'claude-opus-5-5' }] }
: url.pathname === '/v8/management/config/api-keys/claude' ? []
: url.pathname === '/v8/management/config/access/api-keys' ? []
: null;
if (answer === null) { res.writeHead(404); res.end('{}'); return; }
res.end(JSON.stringify(answer));
});
await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, '127.0.0.1', resolve); });
t.after(async () => { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); });
return { port: server.address().port, seen, server };
}
// One instance (config dir + data root) and a fake proxy install whose bytes a test pin names.
// The pin keeps the shipped version, so the pinned binary path is the one loadProxy accepts.
function instance(t) {
const root = fs.mkdtempSync(join(tmpdir(), 'pk-'));
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
const configDir = join(root, 'config'), dataRoot = join(root, 'instance');
fs.mkdirSync(join(configDir, 'secrets', 'agents'), { recursive: true, mode: 0o700 });
fs.chmodSync(join(configDir, 'secrets'), 0o700);
fs.mkdirSync(dataRoot, { mode: 0o700 });
const paths = installPaths(dataRoot);
fs.mkdirSync(join(paths.dir, 'static'), { recursive: true, mode: 0o700 });
fs.writeFileSync(paths.binary, 'fixture proxy binary\n', { mode: 0o700 });
fs.writeFileSync(paths.panel, '<!doctype html>\n', { mode: 0o600 });
const pin = { ...PIN, binary: { ...PIN.binary, sha256: sha('fixture proxy binary\n') }, panel: { ...PIN.panel, sha256: sha('<!doctype html>\n') } };
const rolesDir = rolesCopy(root), system = systemFor(root);
const key = `pk1873-${randomBytes(24).toString('hex')}`;
return { root, configDir, dataRoot, paths, pin, rolesDir, system, key, closers: [] };
}
// A real organization bus on the instance, started with no proxy (as cli bootConfig does when the
// instance has no proxy.json at boot).
async function orgBus(t, f, id, { providers = ['cliproxy'], edit = () => {}, org = { id }, binding = {} } = {}) {
const doc = businessDoc(f.root, id);
doc.plugins = { harness: ['pi'], 'model-provider': providers };
edit(doc);
writeJson(join(f.configDir, 'businesses', `${id}.json`), doc);
const business = loadBusiness(id, { dir: f.configDir, rolesDir: f.rolesDir }), resolved = {};
for (const name of Object.keys(business.roles)) resolved[name] = resolveInstance({ system: f.system, business, instance: name });
const dataRoot = join(f.root, `${id}-bus`); fs.mkdirSync(dataRoot, { mode: 0o700 }); new Registry(dataRoot);
const bus = await startBroker({ dataRoot, businesses: { [id]: busOrganization(business, resolved) },
organization: { dir: f.configDir, rolesDir: f.rolesDir, system: f.system },
instanceRoot: f.dataRoot, org, instanceDataRoot: f.dataRoot, instanceConfigDir: f.configDir,
initProxy: args => initializeProxy({ ...args, pin: f.pin }), ...binding });
t.after(() => bus.close().catch(() => {}));
const human = bus.broker.bindHuman({ business: id, human: 'jason', via: 'cli', outsideAgent: true });
const ask = (verb, args) => Promise.resolve().then(() => bus.broker.request(human, { verb, args }));
return { bus, ask, dataRoot };
}
// Every stderr line written while `run` is in flight.
async function capture(run) {
const write = process.stderr.write, lines = [];
process.stderr.write = (chunk, ...rest) => { lines.push(String(chunk)); return write.call(process.stderr, chunk, ...rest); };
try { return { value: await run(), lines }; } finally { process.stderr.write = write; }
}
// The proxy init through bus A writes proxy.json and the key, then the proxy starts on that port.
async function initThroughA(t, f, a) {
const settings = await a.ask('proxy.init', { key: f.key });
const proxy = await fakeProxy(t, f.key, settings.port);
return { settings, proxy };
}
const notConfigured = (pattern) => e => e.code === 'not-configured' && typeof e.reason === 'string' && pattern.test(e.reason) && e.reason.length <= 300;
test('a running organization bus answers accounts and a cliproxy catalogue once another bus initialized the shared proxy, with no restart', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
// Before init: bus B has nothing to pick up, and says so.
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/not been set up/));
const before = await b.ask('routes');
assert.equal(before.catalogue.status, 'unavailable');
assert.equal(before.catalogue.reason, 'proxy-not-configured');
assert.equal(before.catalogue.notices.length, 1);
const { proxy } = await initThroughA(t, f, a);
// Bus A holds the client from its own init; bus B picks it up at its next read.
assert.deepEqual((await a.ask('proxy.accounts', {})).accounts.map(r => r.provider), ['claude']);
const accounts = await b.ask('proxy.accounts', {});
assert.deepEqual(accounts.accounts.map(r => [r.provider, r.status]), [['claude', 'ready']]);
const after = await b.ask('routes');
assert.equal(after.catalogue.status, 'ready');
assert.deepEqual(after.catalogue.models.map(m => m.key), ['claude-claude-opus-5-5']);
assert.equal(after.catalogue.reason, undefined);
assert.equal(proxy.seen.wrongKey, 0);
// Bus B reached the proxy through the same lock identity the start path uses.
assert.ok(createProxyLock({ stateDir: join(f.dataRoot, 'proxy'), identity: `${f.configDir}:${proxy.port}` }));
});
test('a bus started before the proxy existed and asked only for a catalogue picks the proxy up', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
assert.equal((await b.ask('routes')).catalogue.status, 'unavailable');
await initThroughA(t, f, a);
assert.equal((await b.ask('routes')).catalogue.status, 'ready');
});
// Each case writes the shared proxy's files by hand into a state the start path refuses.
const refusedStates = [
['proxy.json names an unpinned binary', /settings do not load/, f => writeJson(join(f.configDir, 'proxy.json'), { port: 40999, binary: '/elsewhere/cli-proxy-api' })],
['proxy.json is not JSON', /settings do not load/, f => fs.writeFileSync(join(f.configDir, 'proxy.json'), '{', { mode: 0o600 })],
['the management key file is readable by others', /management key does not load/, f => {
writeJson(join(f.configDir, 'proxy.json'), { port: 40999, binary: f.paths.binary });
fs.writeFileSync(join(f.configDir, 'secrets', 'proxy-management.key'), f.key, { mode: 0o644 });
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o644);
}],
['the management key file is missing', /management key does not load/, f => writeJson(join(f.configDir, 'proxy.json'), { port: 40999, binary: f.paths.binary })],
['the proxy state names another port', /proxy lock/, f => {
writeJson(join(f.configDir, 'proxy.json'), { port: 40999, binary: f.paths.binary });
fs.writeFileSync(join(f.configDir, 'secrets', 'proxy-management.key'), f.key, { mode: 0o600 });
fs.mkdirSync(join(f.dataRoot, 'proxy'), { mode: 0o700 });
createProxyLock({ stateDir: join(f.dataRoot, 'proxy'), identity: `${f.configDir}:40998` });
}],
['the proxy state directory is open to others', /proxy lock/, f => {
writeJson(join(f.configDir, 'proxy.json'), { port: 40999, binary: f.paths.binary });
fs.writeFileSync(join(f.configDir, 'secrets', 'proxy-management.key'), f.key, { mode: 0o600 });
fs.mkdirSync(join(f.dataRoot, 'proxy'), { mode: 0o755 }); fs.chmodSync(join(f.dataRoot, 'proxy'), 0o755);
}],
];
for (const [name, cause, arrange] of refusedStates) test(`no pickup when ${name}: accounts and catalogue refuse with the cause`, async t => {
const f = instance(t);
const b = await orgBus(t, f, 'beta');
arrange(f);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(cause));
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.equal(view.catalogue.reason, 'proxy-not-configured');
assert.match(view.catalogue.notices[0], cause);
assert.equal(b.bus.modelProxy, null);
});
// The host refuses fixture-proxy-configured only when a dev fixture is recorded for the instance.
const recordFixture = f => {
fs.mkdirSync(join(f.dataRoot, 'dev-fixture'), { mode: 0o700 });
fs.writeFileSync(join(f.dataRoot, 'dev-fixture', 'fixture.json'), '{}\n', { mode: 0o600 });
};
test('no pickup for an organization on the fixture model provider, which the host refuses with a proxy', async t => {
const f = instance(t);
recordFixture(f);
const a = await orgBus(t, f, 'alpha');
const b = await orgBus(t, f, 'beta', { providers: ['fixture', 'cliproxy'], edit: doc => { doc.launch.models[FIXTURE_KEY_NAME] = { ...FIXTURE_ENTRY }; } });
await initThroughA(t, f, a);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/fixture-proxy-configured/));
assert.equal(b.bus.modelProxy, null);
const view = await b.ask('routes');
assert.equal(view.catalogue.reason, 'proxy-not-configured');
assert.match(view.catalogue.notices[0], /fixture/);
});
test('no pickup for an organization whose launch table names the fixture module only', async t => {
const f = instance(t);
recordFixture(f);
const a = await orgBus(t, f, 'alpha');
const b = await orgBus(t, f, 'beta', { edit: doc => { doc.launch.models[FIXTURE_KEY_NAME] = { ...FIXTURE_ENTRY }; } });
await initThroughA(t, f, a);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/fixture-proxy-configured/));
assert.equal(b.bus.modelProxy, null);
});
test('an organization that lists the fixture still picks the proxy up when no fixture is recorded, as the host would start it', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha');
const b = await orgBus(t, f, 'beta', { providers: ['fixture', 'cliproxy'] });
await initThroughA(t, f, a);
await b.ask('proxy.accounts', {});
assert.ok(b.bus.modelProxy);
// A fixture recorded later drops the client at the next request.
recordFixture(f);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/fixture-proxy-configured/));
assert.equal(b.bus.modelProxy, null);
});
test('a picked-up client is dropped when proxy.json goes away, its port changes, or the key stops loading', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
const { settings } = await initThroughA(t, f, a);
await b.ask('proxy.accounts', {});
assert.ok(b.bus.modelProxy);
const file = join(f.configDir, 'proxy.json'), keyFile = join(f.configDir, 'secrets', 'proxy-management.key');
const saved = fs.readFileSync(file);
// Port change: the lock identity is bound to the port, so the bus refuses until a restart.
writeJson(file, { ...settings, port: settings.port + 1 === 8317 ? settings.port + 2 : settings.port + 1 });
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/proxy lock/));
assert.equal(b.bus.modelProxy, null);
assert.equal((await b.ask('routes')).catalogue.status, 'unavailable');
// Back to the original port, the bus picks it up again.
fs.writeFileSync(file, saved);
await b.ask('proxy.accounts', {});
assert.ok(b.bus.modelProxy);
// Key file no longer 0600.
fs.chmodSync(keyFile, 0o640);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/management key does not load/));
assert.equal(b.bus.modelProxy, null);
fs.chmodSync(keyFile, 0o600);
await b.ask('proxy.accounts', {});
// proxy.json removed.
fs.rmSync(file);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/not been set up/));
assert.equal(b.bus.modelProxy, null);
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.equal(view.catalogue.reason, 'proxy-not-configured');
});
test('a default-instance bus (no organization binding, no lock) follows a port change to the new client, never the old one', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), d = await orgBus(t, f, 'delta', { org: null });
const { settings, proxy } = await initThroughA(t, f, a);
assert.deepEqual((await d.ask('proxy.accounts', {})).accounts.map(r => r.provider), ['claude']);
const old = d.bus.modelProxy;
// A listener on the new port that answers nothing to the right key: reaching it proves the move.
const moved = await fakeProxy(t, `other-${f.key.slice(0, 6)}`);
writeJson(join(f.configDir, 'proxy.json'), { ...settings, port: moved.port });
const before = proxy.seen.calls;
await assert.rejects(d.ask('proxy.accounts', {}));
assert.ok(d.bus.modelProxy && d.bus.modelProxy !== old);
assert.ok(moved.seen.calls > 0);
assert.equal(proxy.seen.calls, before);
});
test('a picked-up bus reads its catalogue through the shared lock: a fence makes it unavailable', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
const { proxy } = await initThroughA(t, f, a);
assert.equal((await b.ask('routes')).catalogue.status, 'ready');
createProxyLock({ stateDir: join(f.dataRoot, 'proxy'), identity: `${f.configDir}:${proxy.port}` }).fence({ org: 'alpha' });
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.ok(b.bus.modelProxy, 'the client stays; the fence alone holds the catalogue');
});
test('a fixture record path in any state but absent counts as recorded', async t => {
const f = instance(t);
fs.writeFileSync(join(f.dataRoot, 'dev-fixture'), 'not a directory\n', { mode: 0o600 });
const a = await orgBus(t, f, 'alpha');
const b = await orgBus(t, f, 'beta', { providers: ['fixture', 'cliproxy'] });
await initThroughA(t, f, a);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/fixture-proxy-configured/));
assert.equal(b.bus.modelProxy, null);
});
test('with a fixture recorded, an organization document that no longer validates counts as using it', async t => {
const f = instance(t);
recordFixture(f);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
fs.writeFileSync(join(f.configDir, 'businesses', 'beta.json'), '{', { mode: 0o600 });
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/fixture-proxy-configured/));
assert.equal(b.bus.modelProxy, null);
});
test('the bus that ran init also drops its client when the key stops loading', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha');
await initThroughA(t, f, a);
await a.ask('proxy.accounts', {});
fs.rmSync(join(f.configDir, 'secrets', 'proxy-management.key'));
await assert.rejects(a.ask('proxy.accounts', {}), notConfigured(/management key does not load/));
assert.equal(a.bus.modelProxy, null);
});
test('an init whose lock refuses leaves the init bus holding no client: no ready catalogue without the lock', async t => {
const f = instance(t);
// The real init, then the proxy state dir is left readable by the group, which the lock refuses.
const initProxy = async args => { const settings = await initializeProxy({ ...args, pin: f.pin });
fs.mkdirSync(join(f.dataRoot, 'proxy'), { recursive: true }); fs.chmodSync(join(f.dataRoot, 'proxy'), 0o750); return settings; };
const a = await orgBus(t, f, 'alpha', { binding: { initProxy } });
await assert.rejects(a.ask('proxy.init', { key: f.key }));
await fakeProxy(t, f.key, JSON.parse(fs.readFileSync(join(f.configDir, 'proxy.json'), 'utf8')).port);
assert.equal(a.bus.modelProxy, null);
const view = await a.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.match(view.catalogue.notices[0], /proxy-lock-invalid/);
assert.equal(a.bus.modelProxy, null);
});
test('a default-instance bus (no lock generation) refreshes its catalogue at once on pickup and on drop', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), d = await orgBus(t, f, 'delta', { org: null });
// An unavailable catalogue read before init must not be served after the pickup.
assert.equal((await d.ask('routes')).catalogue.status, 'unavailable');
await initThroughA(t, f, a);
assert.equal((await d.ask('routes')).catalogue.status, 'ready');
// A ready catalogue read through the picked-up client must not be served after the drop.
fs.rmSync(join(f.configDir, 'proxy.json'));
const gone = await d.ask('routes');
assert.equal(gone.catalogue.status, 'unavailable');
assert.equal(gone.catalogue.reason, 'proxy-not-configured');
assert.equal(d.bus.modelProxy, null);
});
test('a picked-up bus clears a proxy fence through the same client and lock', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
// proxy.fence.clear on a bus that has not read anything yet still picks the proxy up first; the
// restart evidence check is the existing one and refuses this empty evidence.
await assert.rejects(b.ask('proxy.fence.clear', { evidence: {} }));
assert.ok(b.bus.modelProxy);
});
test('a bus serving an invalid organization id never picks up a proxy', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha');
await initThroughA(t, f, a);
let b;
try { b = await orgBus(t, f, 'beta', { binding: { instanceConfigDir: 42 } }); }
catch (error) { assert.equal(error.code, 'invalid-host-request'); return; }
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/organization binding/));
assert.equal(b.bus.modelProxy, null);
});
test('the management key is in no stderr line, response, refusal, event or file the pickup path writes', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
const outputs = [];
const { lines } = await capture(async () => {
outputs.push(await b.ask('proxy.accounts', {}));
outputs.push(await b.ask('routes'));
// A refusal after the key stops loading, and the pickup after it loads again.
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o644);
await b.ask('proxy.accounts', {}).catch(error => outputs.push({ code: error.code, reason: error.reason, message: error.message, next: error.next }));
outputs.push(await b.ask('routes'));
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o600);
outputs.push(await b.ask('proxy.accounts', {}));
});
assert.ok(lines.some(line => line.startsWith('model-proxy: ')), 'the pickup client writes its usual receipts');
assert.equal(lines.join('').includes(f.key), false, 'stderr');
assert.equal(JSON.stringify(outputs).includes(f.key), false, 'responses');
// Every file under bus B's data root (store, WAL, sessions) and the proxy state directory,
// except the proxy's own config.yaml that init writes for the proxy process.
const walk = dir => fs.readdirSync(dir, { withFileTypes: true }).flatMap(e => e.isDirectory() ? walk(join(dir, e.name)) : e.isFile() ? [join(dir, e.name)] : []);
const files = [...walk(b.dataRoot), ...walk(join(f.dataRoot, 'proxy')).filter(p => !p.endsWith('/config.yaml'))];
assert.ok(files.length > 0);
for (const file of files) assert.equal(fs.readFileSync(file).includes(f.key), false, file);
});
+1 -1
View File
@@ -90,7 +90,7 @@ const ask = (x, state, extra = {}) => x.call('pm', 'request.question', { request
options: [{ key: 'web', text: 'Web' }, { key: 'cli', text: 'CLI' }], ...extra });
test('the console verb list includes the artifact read and existing owner controls', () => {
assert.deepEqual([...CONSOLE_VERBS], ['project.remote.get.console', 'project.remote.set.console', 'autonomy.get.console', 'autonomy.set.console', 'autonomy.review.console', 'decision.confirm.console', 'decision.reverse.console', 'request.workspace.console', 'request.artifact.console', 'decision.preview.console', 'decision.resolve.console', 'hire.preview.console', 'hire.resolve.console', 'hire.start.console', 'hire.templates.console', 'prd.revoke.console', 'request.mode.console', 'request.draft.console',
assert.deepEqual([...CONSOLE_VERBS], ['project.remote.get.console', 'project.remote.set.console', 'autonomy.get.console', 'autonomy.set.console', 'autonomy.review.console', 'decision.confirm.console', 'decision.reverse.console', 'request.workspace.console', 'request.artifact.console', 'decision.preview.console', 'decision.resolve.console', 'hire.preview.console', 'hire.resolve.console', 'hire.start.console', 'hire.templates.console', 'pack.hire.console', 'prd.revoke.console', 'request.mode.console', 'request.draft.console',
'request.get.console', 'request.projects.console', 'request.answer.console', 'request.attach.console', 'request.cancel.console',
// Starter packs SP4 (#1873): the owner's pack list and preview, and the three pack writes.
'packs.console', 'pack.preview.console', 'pack.apply.console', 'board.set.console', 'workflow.set.console',
+165
View File
@@ -0,0 +1,165 @@
// #1873 lane triage-fence: through the broker, no organization gains the system-only Triage
// template. Pack preview and apply, the Console hire start, the chief's hire.raise and
// decision.raise, and instances.set add as the human and the tester each refuse with
// template-system-only; the Console's hire template list omits triage. The coding pack still
// previews as before. Fixtures live in a temp directory.
import test from 'node:test';
import assert from 'node:assert/strict';
import { chmodSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { Broker } from '../src/broker.mjs';
import { Store } from '../src/store.mjs';
import { pluginHash } from '../../plugins/src/pinned.mjs';
import { installPlugin } from '../../plugins/src/install.mjs';
import { starterPack as codingPack } from '../../plugins/starter-pack/coding/index.mjs';
import { templateHash } from '../../organization/src/definitions.mjs';
import { hireDecisions } from '../../organization/src/hire-decisions.mjs';
import { organizationWriter } from '../../organization/src/organization.mjs';
import { loadBusiness } from '../../organization/src/organization-config.mjs';
import { businessDoc, rolesCopy, systemFor, writeJson } from '../../organization/tests/helpers.mjs';
const CODE = 'template-system-only';
const SUBJECT = { provider: 'test', iss: 'https://issuer.test', sub: 'owner' };
const ROUTE = { harness: 'pi', model: 'claude-opus-5-5' };
// The broker started as the runtime starts it, with the organization writer and installed packs.
async function runtime(t) {
const { startBroker } = await import('../src/runtime.mjs');
const root = mkdtempSync(join(tmpdir(), 'sobus-'));
const rolesDir = rolesCopy(root);
const doc = businessDoc(root, 'demo');
doc.plugins = { harness: ['pi'] };
doc.roles.chief.vars = { ...ROUTE };
writeJson(join(root, 'businesses/demo.json'), doc);
const data = join(root, 'data');
mkdirSync(data, { mode: 0o700 });
const roles = { chief: { definition: 'chief-of-staff', authority: { withinRole: ['decision.resolve.technical', 'decision.resolve.delivery', 'organization.change'], crossRole: [] } } };
const businesses = { demo: { id: 'demo', human: 'jason', arbiters: { technical: 'chief', delivery: 'chief' }, roles, vars: { 'bus.tester': true } } };
const bus = await startBroker({ dataRoot: data, businesses, organization: { dir: root, rolesDir, system: systemFor(root) } });
const thaw = (p) => { const st = lstatSync(p); if (st.isSymbolicLink()) return; if (st.isDirectory()) { chmodSync(p, 0o700); for (const e of readdirSync(p)) thaw(join(p, e)); } };
t.after(async () => { await bus.close(); thaw(root); rmSync(root, { recursive: true, force: true }); });
const b = bus.broker;
const owner = b.bindConsole({ business: 'demo', human: 'jason', subject: SUBJECT });
const human = b.bindHuman({ business: 'demo', human: 'jason', via: 'cli', outsideAgent: true });
const tester = b.bindTester({ business: 'demo' });
const call = async (verb, args = {}, cap = owner) => b.request(cap, { verb, args });
const file = () => readFileSync(join(root, 'businesses/demo.json'), 'utf8');
let n = 0;
const install = (pack) => {
const src = join(root, `src-${n++}`);
mkdirSync(join(src, 'starter-pack'), { recursive: true });
writeFileSync(join(src, 'starter-pack', 'index.mjs'), `export const interfaceVersion = 1;\nexport function starterPack() { return ${JSON.stringify(pack)}; }\n`);
const manifest = { name: pack.id, version: '1.0.0', kinds: ['starter-pack'], interfaceVersions: { 'starter-pack': 1 }, sha256: '0'.repeat(64),
source: { path: 'fixture', version: '1.0.0' }, signature: null, tools: [], actions: [], services: [], roleTemplates: [] };
writeFileSync(join(src, 'plugin.json'), JSON.stringify(manifest));
manifest.sha256 = pluginHash(src);
writeFileSync(join(src, 'plugin.json'), JSON.stringify(manifest));
installPlugin({ dataRoot: data, source: src, expectedHash: manifest.sha256 });
};
return { b, root, rolesDir, owner, human, tester, call, file, install };
}
// The A4 broker with the real hire service, so the chief's raise and the Console start reach it.
function hires(t) {
const root = mkdtempSync(join(tmpdir(), 'sohire-')), rolesDir = rolesCopy(root);
writeJson(join(root, 'businesses/demo.json'), { ...businessDoc(root, 'demo'), plugins: { harness: ['pi'] } });
const storeRoot = join(root, 'data'); mkdirSync(storeRoot, { mode: 0o700 });
const writer = organizationWriter({ dir: root, rolesDir }), store = new Store(storeRoot);
const service = hireDecisions({ writer, rolesDir, dataRoot: storeRoot, configDir: root, assertClean: () => {} });
const loaded = () => { const doc = loadBusiness('demo', { dir: root, rolesDir }); return { ...doc, roles: Object.fromEntries(Object.entries(doc.roles).map(([k, e]) => [k, { ...doc.definitions[e.definition], ...e }])) }; };
const b = new Broker({ store, businesses: { demo: loaded() }, hires: service });
t.after(() => { store.close(); rmSync(root, { recursive: true, force: true }); });
const owner = b.bindConsole({ business: 'demo', human: 'jason', subject: SUBJECT });
const chief = b.bindLaunch({ business: 'demo', role: 'chief', run: 'chief-run', harness: 'pi' });
b.request(chief, { verb: 'role.claim' });
const call = (cap, verb, args = {}) => b.request(cap, { verb, args });
const triage = { template: 'triage', sha256: templateHash(rolesDir, 'triage') };
const hire = (extra = {}) => ({ op: 'hire', level: 'org', name: 'sorter', role: triage, route: ROUTE, reason: 'Sort the inbox', ...extra });
const decisions = () => store.get('SELECT count(*) n FROM decisions').n;
return { owner, chief, call, hire, decisions };
}
const refuses = async (promise) => assert.rejects(Promise.resolve().then(() => promise), (e) => e?.code === CODE);
test('pack preview refuses an installed pack that defines triage', async (t) => {
const h = await runtime(t);
const pack = { ...codingPack(), id: 'sorting', label: 'Sorting' };
pack.definitions = { ...pack.definitions, triage: { template: 'triage', sha256: templateHash(h.rolesDir, 'triage') } };
h.install(pack);
const before = h.file();
await refuses(h.call('pack.preview.console', { pack: 'sorting' }));
assert.equal(h.file(), before);
});
test('pack apply refuses an installed pack that defines triage', async (t) => {
const h = await runtime(t);
const pack = { ...codingPack(), id: 'sorting', label: 'Sorting' };
pack.definitions = { ...pack.definitions, triage: { template: 'triage', sha256: templateHash(h.rolesDir, 'triage') } };
h.install(pack);
const before = h.file();
await refuses(h.call('pack.apply.console', { pack: 'sorting', digest: 'a'.repeat(64) }));
assert.equal(h.file(), before);
});
test('instances.set add refuses triage for the human', async (t) => {
const h = await runtime(t);
const { revision } = await h.call('instances', {}, h.human);
const before = h.file();
await refuses(h.call('instances.set', { revision, instance: 'sorter', op: 'add', definition: 'triage' }, h.human));
assert.equal(h.file(), before);
});
test('instances.set add refuses triage for the tester', async (t) => {
const h = await runtime(t);
const { revision } = await h.call('instances', {}, h.human);
const before = h.file();
await refuses(h.call('instances.set', { revision, instance: 'sorter', op: 'add', definition: 'triage' }, h.tester));
assert.equal(h.file(), before);
});
test('the instances read offers no triage add', async (t) => {
const h = await runtime(t);
const view = await h.call('instances', {}, h.human);
assert.equal(Object.hasOwn(view.definitions, 'triage'), false);
});
test('the Console hire start refuses a triage template', async (t) => {
const f = hires(t);
await refuses(f.call(f.owner, 'hire.start.console', f.hire()));
assert.equal(f.decisions(), 0);
});
test('the chief hire.raise refuses a triage template at org, project and root level', async (t) => {
const f = hires(t);
await refuses(f.call(f.chief, 'hire.raise', f.hire()));
await refuses(f.call(f.chief, 'hire.raise', f.hire({ level: 'project', project: 'stack' })));
await refuses(f.call(f.chief, 'hire.raise', f.hire({ level: 'root' })));
assert.equal(f.decisions(), 0);
});
test('the chief decision.raise naming role.hire or role.change refuses a triage template', async (t) => {
const f = hires(t);
await refuses(f.call(f.chief, 'decision.raise', { action: 'role.hire', hire: f.hire() }));
await refuses(f.call(f.chief, 'decision.raise', { action: 'role.change', hire: f.hire({ op: 'change', name: 'coder' }) }));
assert.equal(f.decisions(), 0);
});
test('the Console hire template list omits triage and keeps the rest', async (t) => {
const f = hires(t);
const names = (await f.call(f.owner, 'hire.templates.console')).templates.map((x) => x.name);
assert.ok(!names.includes('triage'));
assert.ok(names.includes('coder') && names.includes('reviewer'));
});
// The guard: a shipped pack previews and applies as before, and an installed pack with no triage loads.
test('the shipped coding pack and an installed pack without triage preview as before', async (t) => {
const h = await runtime(t);
const preview = await h.call('pack.preview.console', { pack: 'coding' });
assert.match(preview.digest, /^[a-f0-9]{64}$/);
h.install({ ...codingPack(), id: 'plain', label: 'Plain' });
const plain = await h.call('pack.preview.console', { pack: 'plain' });
assert.match(plain.digest, /^[a-f0-9]{64}$/);
const out = await h.call('pack.apply.console', { pack: 'coding', digest: preview.digest });
assert.deepEqual(out.hires.map((x) => [x.name, x.state]), [['pm-1', 'hired'], ['coder-1', 'hired'], ['reviewer-1', 'hired']]);
});
+1 -1
View File
@@ -154,7 +154,7 @@ test('SP8 argument checks: a second save, a .. name, an unknown key, preview wit
const { call, saved } = await harness(t);
const { preview } = await save(call, 'demo-shape');
const first = readFileSync(saved('demo-shape'));
await assert.rejects(call('template.save.console', { name: 'demo-shape', digest: preview.digest }), (e) => e.code === 'invalid-request' && e.reason === 'a template of this name is already saved');
await assert.rejects(call('template.save.console', { name: 'demo-shape', digest: preview.digest }), (e) => e.code === 'template-exists' && e.reason === 'a template of this name is already saved; save under another name');
assert.deepEqual(readFileSync(saved('demo-shape')), first);
for (const name of ['..', '../x', 'a/b']) await assert.rejects(call('template.save.console', { name, preview: true }), { code: 'invalid-request' });
for (const args of [{ name: 'x', preview: true, account: 'alex' }, { name: 'x', preview: true, digest: preview.digest }, { name: 'x' }, { preview: true }, { name: 'x', preview: false }])
+21
View File
@@ -121,3 +121,24 @@ test('committed mutation followed by dropped reply reports unknown and is never
assert.equal(calls, 1);
assert.equal(store.get('SELECT count(*) n FROM messages').n, 1);
});
// E2E6 fix 6: a connect that fails before the request is written is marked notSent; the code stays
// outcome-unknown for every caller. A request that left and got no answer is not marked.
test('E2E6 a failed connect is outcome-unknown marked notSent; a dropped answer is not marked', async (t) => {
const { createServer } = await import('node:net');
const { writeFileSync } = await import('node:fs');
const { NOT_SENT_EXIT } = await import('../src/client.mjs');
assert.equal(NOT_SENT_EXIT, 5);
const dir = mkdtempSync(join(tmpdir(), 'e2e6-'));
t.after(() => rmSync(dir, { recursive: true, force: true }));
const plain = join(dir, 'plain');
writeFileSync(plain, '');
for (const path of [join(dir, 'missing.sock'), plain, join(plain, 'below')]) {
await assert.rejects(new Client({ path, cap: 'x' }).call('inbox', {}), (e) => e.code === 'outcome-unknown' && e.notSent === true, path);
}
const sock = join(dir, 'drop.sock');
const server = createServer((c) => c.once('data', () => c.destroy()));
await new Promise((r) => server.listen(sock, r));
t.after(() => server.close());
await assert.rejects(new Client({ path: sock, cap: 'x' }).call('inbox', {}), (e) => e.code === 'outcome-unknown' && e.notSent === undefined);
});
+114
View File
@@ -1363,6 +1363,23 @@ message, an answer that never came exits 1, an unknown template exits 2. All of
these verbs, reads included, refuse inside an agent run (exit 3) after their
usage checks (exit 4) and before any config is read.
Starter pack hires (ruling 2026-11-14, #1873): `mosaic org pack apply ID PACK
--digest D [--project P]` is the owner's hire decision. After the pack commits,
the same command hires each proposed agent through the bus's hire-decisions
path (`pack.apply` as the organization's human) and the receipt adds `hires`,
one `{name, state, decision | code}` per proposal: `hired`, `exists` (an
instance by that name is there), `open` (a hire decision already names it),
`awaiting-owner` or `refused` with the hire's code. The owner's apply approves
the flagged and credential lines; a credential line is approved, not bound, so
the agent's launch is refused `credential-unbound` until its services are
bound. `mosaic org pack hire ID PACK [--project P]` (`pack.hire`) runs the same
loop on a pack already applied, for the proposals an earlier apply left open,
and hires none twice; a pack with no packs entry is refused `pack-not-applied`
with the hint to preview and apply it first. A proposal is refused
`pack-hire-route-missing` when neither the chief of staff nor the
organization's assistant has a harness and model to give it; the chief's route
wins when both have one. Like the other pack words, both refuse inside an agent run (exit 3).
`mosaic tasks create|edit|archive` are the task board's three writes. The
arguments pass the board's own check, then go to the bus as the person
(`tasks.create`, `tasks.edit`, `tasks.archive`), so the bus runs its human,
@@ -1408,3 +1425,100 @@ installer writes `<dataRoot>/.deployed` as mode 0444 naming the instance.
`webui-service.sh` refuses accounts and deployed instances because its user
manager runs under a human or development seat uid. The receipt uid identifies
the invoking process; it does not attribute a human or resist tampering by that uid.
## Triage route (#1873, held for Jason's ruling)
`mosaic triage route show` prints the Triage route the instance owner set, or
`triage route: not set` (exit 0). `mosaic triage route set --model KEY
--harness NAME --cap TOKENS --time-zone ZONE [--revision N]` writes it. Both
refuse inside an agent run before anything is read (exit 3).
The file is `<dataRoot>/triage/route.json`
(packages/webui/src/triage-route-store.mjs): a catalogue model key, a harness
name and a daily cap leaf `{limit, since, reset, timeZone}`. It holds no env
value and no key. The day resets at 00:00 in the zone given, which has no
default; an unknown zone refuses. The first cap counts from the time it is
set; a later change keeps that `since`, as an organization's token limits do,
so lowering the cap never drops tokens already spent. The directory is 0700 and the file 0600,
owned by the running user; a link, a non-file, a wrong mode or owner, or an
unknown field refuses (exit 3). A write is compare-and-set on `revision`
(`--revision 0`: only when nothing is set), atomic, and appends one line with
the old and new values to `route-receipts.jsonl`. A write that died leaves
`route.lock`; the next write refuses and names it, and you remove it by hand.
If the route changed but its receipt line could not be written, the write
refuses with `triage-route-unrecorded` (exit 3) and names the new revision.
`set` checks the harness against packages/plugins/harness/; it does not check
the model key against a catalogue yet.
The Console does not read this file: the Triage host keeps `route: null` until
the wiring slice.
## Triage key (#1873)
`mosaic triage key issue|rotate|retire|status` manage Triage's own model
proxy client key. Every verb refuses inside an agent run before anything is
read (exit 3), and takes no options.
The key is `mst-<tag>-triage-<43 base64url>`, where `<tag>` is the first 12
hex of sha256 of the config directory, the tag on the instance's own `msk-`
sentinel. An org bus reconciles only its `mso-<tag>-<org>-key-` names and a
no-org bus only its `msk-<tag>-` names, so neither removes it. The file is
`<configDir>/secrets/triage/model`: `{version, key, keyId, issuedAt,
rotateBy, retiring}`. The directory is 0700 and the file 0600, owned by the
running user. A link, a non-file, a second hard link, a wrong mode or owner, a
file over 64 KiB, or a record that does not match the shape refuses every verb
with `triage-key-unreadable` (exit 3).
- `issue` adds one key and writes the file. It refuses `triage-key-issued`
when a key is already issued; that is `rotate`.
- `rotate` adds a new key and moves the old one to `retiring`, with a retire
time of now plus `rotateGraceMinutes` from proxy.json, where the bus reads
it (default 120). `rotateBy` is 30 days on, as for an org key. An old key
the proxy no longer holds is dropped at once.
- `retire` removes retiring keys whose grace has passed or that the proxy no
longer holds. It changes nothing before then.
Nothing runs on a timer. The retire time is the earliest a retiring key may
go; the key stays live in the proxy until someone runs `retire` (or a later
`rotate` or `issue`) after it. `rotateBy` works the same way: `status` marks
it due, and only `rotate` replaces the key.
- `status` prints whether a key is issued, its key id, its age, its rotate-by
day, each retiring key, what the proxy list holds, a set fence, any key in
the Triage namespace the file does not hold, and the next command. It takes
no lock and writes nothing.
`issue`, `rotate` and `retire` hold the instance proxy lock that org buses
take (`<dataRoot>/proxy`). Each reads the list, refuses without this
instance's sentinel (`triage-key-proxy-open`), reads it again and refuses if
it moved (`triage-key-raced`), sets the fence, writes, reads back and clears
the fence. The proxy changes first and the file second. Each run that
changes something appends one line of key ids, never keys, to
`<dataRoot>/proxy/mosaic-keys.receipts.jsonl`. That file is checked under the
lock before anything changes; an unsafe one refuses
`triage-key-receipts-unsafe`. A receipt line that still fails after the change
refuses `triage-key-unrecorded`. No output, error or receipt holds a key.
The file is written to a 0600 temp file in the same directory, synced, renamed
into place, and the directory is synced. A failed directory sync after the
rename refuses `triage-key-unsynced`: the file is in place but may not survive
a power loss. `proxy-lock-busy` means another proxy writer holds the lock; if
none is running, `mosaic proxy fence status` shows the lock state.
After a crash:
- Killed after the proxy write and before the read-back: the fence stays set
and every proxy writer on the instance refuses `proxy-uncertain`. `status`
shows the fence. Restart the proxy, run `mosaic proxy fence clear
--proxy-restarted`, then run the verb again.
- Killed after the read-back and before the file write: the proxy holds a key
the file does not. `status` names it; the next `issue`, `rotate` or `retire`
removes it. A file that could not be written refuses
`triage-key-unwritten` and says to run the verb again.
- Killed after the temp file is written and before its rename: a
`.model.<pid>.<hex>.tmp` file that may hold a key stays in the triage
directory. `status` counts it; the next `issue`, `rotate` or `retire`
removes it under the lock.
- A `retire` killed after the proxy write leaves a retiring key the proxy no
longer holds. `status` marks it; the next `retire` drops it from the file.
Nothing gives the key to the Triage host yet; that is the wiring slice.
+5
View File
@@ -56,6 +56,7 @@ import { ORG_CONFIG, runConfigCommand } from "../../organization/src/config-comm
import { devCommand, DEV_USAGE, fixtureLaunchEnv, fixtureLauncherOptions } from "./dev-fixture.mjs";
import { runCommand, RUN_USAGE } from "./run-evidence.mjs";
import { tasksWriteCommand, TASKS_WRITE_OPS, TASKS_WRITE_USAGE } from "./tasks-write.mjs";
import { triageCommand, TRIAGE_USAGE } from "./triage.mjs";
export const USAGE = `usage:
${ACCOUNTS_USAGE}
@@ -103,6 +104,7 @@ export const USAGE = `usage:
mosaic console start [--dev-local-owner [--dev-insecure-bind ADDR --dev-allow-host NAME[,NAME...]]] [--detach] [--port auto|N]
mosaic console stop|status
mosaic console restart
${TRIAGE_USAGE}
${DEV_USAGE}
${RUN_USAGE}`;
@@ -818,6 +820,8 @@ export async function main(argv, io = { env: process.env, stdin: process.stdin,
if (verb === "launches") return launches(rest, io, deps);
if (verb === "bus") return bus(rest, io, deps);
if (verb === "console") return consoleCommand(rest, io, deps);
// triage-route-store (#1873): the owner's Triage route file, read and written as the person.
if (verb === "triage") return triageCommand(rest, io, deps);
if (verb === "dev") return devCommand(rest, io, { system: deps.system });
if (verb === "run") return runCommand(rest, io, { system: deps.system, callFor: (p) => channelCallFor(p, io, deps) });
if (verb === "-h" || verb === "--help") return io.stdout.write(`${USAGE}\n`);
@@ -845,6 +849,7 @@ export async function run(argv, io = { env: process.env, stdin: process.stdin, s
if (!(error instanceof CliError)) throw error;
io.stderr.write(`mosaic: ${error.message}\n`);
if (OTHER_TREE_CODES.has(error.code)) io.stderr.write(`mosaic: ${OTHER_TREE}\n`);
if (typeof error.next === "string" && error.next !== "") io.stderr.write(`mosaic: next: ${error.next}\n`);
return error.exitCode;
}
}
+5 -1
View File
@@ -3,11 +3,15 @@
// input, a decision or option that doesn't exist); 3 refused (system or
// business config problem, the broker or notifier refused, the human proof
// refused, a host already running); 4 usage.
//
// E2E6: `next` is an optional next-step line. run() prints it after the message as
// `mosaic: next: ...`; the message itself stays as callers (the Console among them) match it.
export class CliError extends Error {
constructor(message, exitCode = 2) {
constructor(message, exitCode = 2, { next } = {}) {
super(message);
this.name = "CliError";
this.exitCode = exitCode;
if (typeof next === "string" && next !== "") this.next = next;
}
}
+7 -1
View File
@@ -76,6 +76,11 @@ const same = (a, b) => a?.pid === b?.pid && a?.startTime === b?.startTime && a?.
// tried again, like one that goes before the check. `found` runs once the
// lock is found and before it is read, `between` after the stale lock is
// read; both are for the tests. Exported for the tests.
// E2E6 fix 1: every stale-lock refusal names the verb that clears a host that died.
export const recoverNext = (business) =>
typeof business === "string" && /^[a-z0-9][a-z0-9._-]{0,63}$/.test(business)
? `if the bus host died, clear it with mosaic bus recover ${business}; recover refuses while the host still runs`
: "if the bus host died, clear it with mosaic bus recover <org>; recover refuses while the host still runs";
export function claimHostLock(dataRoot, state, { found = () => {}, between = () => {}, refuseStale = false } = {}) {
mkdirSync(hostDir(dataRoot), { recursive: true, mode: 0o700 });
const file = hostLock(dataRoot);
@@ -94,7 +99,8 @@ export function claimHostLock(dataRoot, state, { found = () => {}, between = ()
const prior = readState(file, found);
if (!prior) continue;
if (prior.live) throw new CliError(`a bus host already runs for ${prior.business} (pid ${prior.pid})`, 3);
if (refuseStale) throw new CliError("stale bus host lock", 3);
// E2E6 fix 1: the message stays (the Console matches it); the next line names the clearing verb.
if (refuseStale) throw new CliError("stale bus host lock", 3, { next: recoverNext(prior.business) });
between();
try {
renameSync(file, aside);
+11 -9
View File
@@ -8,7 +8,7 @@ import { join } from 'node:path';
import { fileURLToPath } from 'node:url';
import { resolveOrg, withOrgLifecycle } from '../../organization/src/org-registry.mjs';
import { orgPaths } from './config.mjs';
import { cmdlineOf, hostFile, hostLock, hostStatus, readHostState, startTimeOf, stopHost } from './host.mjs';
import { cmdlineOf, hostFile, hostLock, hostStatus, readHostState, recoverNext, startTimeOf, stopHost } from './host.mjs';
import { CliError } from './errors.mjs';
import { readBootStatus } from './boot-status.mjs';
@@ -27,20 +27,22 @@ async function target(ctx, id, allowDeleting = false) {
return { ...org, paths: orgPaths(org.root) };
}
function checkedState(org) {
// E2E6 fix 1: each refusal keeps its message and adds the recover line as its next step.
const stale = message => { throw new CliError(message, 3, { next: recoverNext(org.id) }); };
const s = hostStatus(org.root);
let lock = null;
try { lock = JSON.parse(readFileSync(hostLock(org.root), 'utf8')); }
catch (e) { if (e.code !== 'ENOENT') fail('bus host lock is unreadable'); }
if (lock && (!Number.isSafeInteger(lock.pid) || typeof lock.startTime !== 'string' || startTimeOf(lock.pid) !== lock.startTime)) fail('stale bus host lock');
if (s.host && (!s.host.live || s.host.business !== org.id)) fail('stale or mismatched bus host state');
catch (e) { if (e.code !== 'ENOENT') stale('bus host lock is unreadable'); }
if (lock && (!Number.isSafeInteger(lock.pid) || typeof lock.startTime !== 'string' || startTimeOf(lock.pid) !== lock.startTime)) stale('stale bus host lock');
if (s.host && (!s.host.live || s.host.business !== org.id)) stale('stale or mismatched bus host state');
if (s.host) {
const args = cmdlineOf(s.host.pid) ?? [], i = args.indexOf(CLI);
if (i < 0 || args[i + 1] !== 'bus' || args[i + 2] !== 'start' || args[i + 3] !== org.id) fail('bus host identity mismatch');
if (i < 0 || args[i + 1] !== 'bus' || args[i + 2] !== 'start' || args[i + 3] !== org.id) stale('bus host identity mismatch');
}
if (lock && (!s.host || lock.pid !== s.host.pid || lock.business !== org.id)) fail('bus host lock does not match host state');
if (s.writerLock && !s.writerLock.live) fail('stale bus writer lock');
if (!s.host && s.writerLock) fail('bus writer lock has no matching host');
if (s.host && !lock) fail('bus host lock is missing');
if (lock && (!s.host || lock.pid !== s.host.pid || lock.business !== org.id)) stale('bus host lock does not match host state');
if (s.writerLock && !s.writerLock.live) stale('stale bus writer lock');
if (!s.host && s.writerLock) stale('bus writer lock has no matching host');
if (s.host && !lock) stale('bus host lock is missing');
return s;
}
export function probeBusSocket(path, { signal, deadline } = {}) {
+72 -7
View File
@@ -3,7 +3,7 @@ import { randomBytes } from 'node:crypto';
import { processState } from '../../seat/src/process-state.mjs';
import { spawn } from 'node:child_process';
import { request as httpRequest } from 'node:http';
import { constants, closeSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, rmSync, renameSync, writeFileSync, writeSync } from 'node:fs';
import { constants, closeSync, fstatSync, ftruncateSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, rmSync, renameSync, writeFileSync, writeSync } from 'node:fs';
import { basename, join } from 'node:path';
import { fileURLToPath } from 'node:url';
import { listOrgs, resolveOrg } from '../../organization/src/org-registry.mjs';
@@ -60,14 +60,79 @@ function removeStale(ctx, s, warn) {
warn(`mosaic: stale console state moved to ${aside}\n`);
return true;
}
function takeLock(ctx) {
// E2E6 fix 4: what a start.lock that already exists names. Null when it names no holder: unreadable,
// empty (a holder between its open and its write), not a regular file of this user, or a bad pid or
// start time. Such a lock is never cleared. A lock its holder marked released ({"released":true},
// written through the holder's own descriptor) names no live holder and is cleared (f6c review P3-1).
function lockHolder(path) {
let fd;
try { fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK); }
catch { return null; }
try {
const st = fstatSync(fd);
if (!st.isFile() || st.uid !== process.getuid() || st.nlink !== 1 || st.size > 4096) return null;
const data = JSON.parse(readFileSync(fd, 'utf8'));
if (data?.released === true && Object.keys(data).length === 1) return { released: true, dev: st.dev, ino: st.ino };
if (!Number.isSafeInteger(data?.pid) || data.pid <= 0 || typeof data.startTime !== 'string' || !/^\d+$/.test(data.startTime)) return null;
return { pid: data.pid, startTime: data.startTime, dev: st.dev, ino: st.ino };
} catch { return null; } finally { closeSync(fd); }
}
// True when the process the lock names (pid and start time) is gone. A /proc read that cannot settle
// it counts as live, so an uncertain holder is never cleared.
function holderGone(holder) {
if (holder.released) return true;
let p;
try { p = processState(holder.pid); } catch { return false; }
return !p.alive || p.startTime !== holder.startTime;
}
// Moves aside and removes the lock the holder check read, and only that file: a lock another start
// took in between is put back and the clear refuses.
function clearLock(path, holder) {
const aside = `${path}.dead-${randomBytes(4).toString('hex')}`;
try { renameSync(path, aside); } catch { fail('console start lock changed while it was being cleared; run the command again'); }
const st = lstatSync(aside);
if (st.dev !== holder.dev || st.ino !== holder.ino) {
// Put back without replacing: if a third start took the path meanwhile, the aside stays for a human.
let restored = false;
try { linkSync(aside, path); restored = true; } catch { /* left aside */ }
if (restored) rmSync(aside, { force: true });
fail('console start lock changed while it was being cleared; run the command again');
}
rmSync(aside, { force: true });
}
function takeLock(ctx, warn = () => {}) {
checkDir(ctx);
const path = join(directory(ctx), 'start.lock');
let fd; try { fd = openSync(path, 'wx', 0o600); } catch { fail('console start lock exists'); }
let fd;
for (let cleared = false; fd === undefined;) {
try { fd = openSync(path, 'wx', 0o600); }
catch (e) {
if (e?.code !== 'EEXIST' || cleared) fail('console start lock exists');
// E2E6 fix 4: a lock whose named holder (pid and start time) is gone is cleared once, and the
// take tried again. A live holder, or a lock that names none, refuses and stays.
const holder = lockHolder(path);
if (!holder) fail('console start lock exists and names no holder; remove console/start.lock under the data root once no console start or stop runs');
if (!holderGone(holder)) fail(`console start lock is held by process ${holder.pid}, which still runs; wait for its start or stop to finish`);
clearLock(path, holder);
warn(holder.released ? 'mosaic: cleared a console start lock its holder had released\n' : `mosaic: cleared a console start lock left by process ${holder.pid}, which is gone\n`);
cleared = true;
}
}
// D1: the lock names its holder, so a detached start that timed out can clear the lock of the
// supervisor it killed (clearDeadLock) and no other.
// supervisor it killed (clearDeadLock), and a later start or stop can clear it once that holder is gone.
try { writeSync(fd, JSON.stringify({ pid: process.pid, startTime: startTimeOf(process.pid) })); } catch { /* an unnamed lock is only never cleared */ }
return () => { closeSync(fd); rmSync(path, { force: true }); };
// f6c review P3-1: the release marks its own file released, through its own descriptor, and removes
// the path only while the path is still that file. A clear that moved the lock aside and puts it back
// after this release puts back a released lock, which the next start or stop clears; and the release
// never removes a lock another start took meanwhile.
// A failed marker write (disk full) still removes the path: an empty lock would refuse forever.
return () => {
try {
try { ftruncateSync(fd, 0); writeSync(fd, JSON.stringify({ released: true }), 0); } catch { /* the matched unlink below still runs */ }
const own = fstatSync(fd), now = lstatSync(path);
if (own.dev === now.dev && own.ino === now.ino) rmSync(path, { force: true });
} catch { /* gone already, or moved aside by a clear */ } finally { closeSync(fd); }
};
}
// Removes start.lock only when it names this exact process (pid and start time) and that process
// is gone. A lock that is unreadable, unnamed or another holder's stays.
@@ -242,7 +307,7 @@ export async function consoleStart(ctx, { devLocalOwner = false, detach = false,
// re-check P1). A Restart Console relaunch goes through relaunch(), not here.
refuseInsideAgent(process.env); if (ctx.env) refuseInsideAgent(ctx.env);
if (detach && devLocalOwner) return detachedSupervisor(ctx, { port, bind, allowHosts, warn });
const release = takeLock(ctx);
const release = takeLock(ctx, warn);
let run, args;
try {
const prior = state(ctx);
@@ -266,7 +331,7 @@ export async function consoleStart(ctx, { devLocalOwner = false, detach = false,
return result;
}
export async function consoleStop(ctx, { warn = s => process.stderr.write(s) } = {}) {
const release = takeLock(ctx);
const release = takeLock(ctx, warn);
try {
const s = state(ctx);
if (!s || removeStale(ctx, s, warn)) return { stopped: false };
+34
View File
@@ -4,10 +4,12 @@
// credential store, whose held-secret check every definition write needs (R1), and no other process
// holds the tokens it looks for. Each write prints its receipt.
import { readFile } from 'node:fs/promises';
import { basename } from 'node:path';
import { configDir } from '../../organization/src/organization-config.mjs';
import { organizationWriter } from '../../organization/src/organization.mjs';
import { definitionVerbs } from '../../organization/src/definition-verbs.mjs';
import { checkDefinition } from '../../organization/src/definitions.mjs';
import { ID_PATTERN } from '../../organization/src/vocabulary.mjs';
import { rolesDir } from './config.mjs';
import { CliError } from './errors.mjs';
import { busExit, refuseInsideAgent } from './transport.mjs';
@@ -59,6 +61,33 @@ function refusal(code, verb, name, rev, read) {
return error;
}
// E2E6 fix 2: a read or a write's file check that fails says so in one line: an unknown
// organization, a missing definition or a bad file, by code. No stack trace, and no host path: a raw
// filesystem error is named by its operation and code, and any absolute path left in a message is cut.
const NAME_SHOWN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
function missing(id, name) { return `${NAME_SHOWN.test(name ?? '') ? `definitions declares no ${name}` : 'definitions declares no definition by that name'}; list them with mosaic org definitions ${id} list`; }
// f6c review P3-3: a path after ':' or a backtick is cut too.
function pathFree(message) { return String(message).replace(/(^|[\s'"(=:`])\/[^\s'"),`]*/g, '$1<path>'); }
export function definitionsFailure(e, id, name) {
if (e instanceof CliError) return e;
const coded = (code, text, exit = 3) => Object.assign(new CliError(`${code}: ${text}`, exit), { code });
if (typeof e?.syscall === 'string' && typeof e.code === 'string' && /^E[A-Z0-9]+$/.test(e.code)) {
// f6c review P3-2: only a missing organization file means no organization; another missing file
// (the roles directory for `templates`, a role template) says which operation failed.
if (e.code === 'ENOENT' && (typeof e.path !== 'string' || basename(e.path) === `${id}.json`)) return coded('unknown-organization', `this instance has no organization ${id}; list them with mosaic org list`);
if (id === 'templates' || id === undefined) return coded('definitions-unreadable', `cannot ${e.syscall} a file the definitions command reads (${e.code})`);
return coded('organization-unreadable', `cannot ${e.syscall} the file of organization ${id} (${e.code})`);
}
const message = typeof e?.message === 'string' ? e.message : '';
if (/^definitions declares no /.test(message)) return coded('definition-missing', missing(id, name));
if (typeof e?.code === 'string' && /^[a-z][a-z-]{0,63}$/.test(e.code)) {
const text = e.code === 'definition-missing' ? missing(id, name) : pathFree(message);
return coded(e.code, text);
}
if (e?.name === 'OrganizationConfigError' || e?.name === 'BusinessError') return coded('organization-invalid', pathFree(message));
return coded('definitions-failed', 'the definitions command failed', 1);
}
// deps.callFor(parsed) returns the human's call(verb, args) for the organization parsed names (cli.mjs
// passes its callFor). Without one, a write refuses: it never runs without the bus's secret check.
export async function definitionsCommand(args, io, deps = {}) {
@@ -68,6 +97,10 @@ export async function definitionsCommand(args, io, deps = {}) {
const ifRev = () => { const r = need('--if-rev'); if (!/^[1-9][0-9]*$/.test(r)) throw new CliError('invalid --if-rev', 4); return Number(r); };
const [id, verb, name] = pos;
if (WRITES.includes(verb)) refuseInsideAgent(io.env);
if (id !== 'templates' && id !== undefined && !ID_PATTERN.test(id)) throw new CliError(`invalid organization id: an id is 1 to 64 of a-z, 0-9, '.', '_' and '-', starting with a letter or digit\n${DEFINITIONS_USAGE}`, 4);
try { await run(); }
catch (e) { throw definitionsFailure(e, id, name); }
async function run() {
const writer = deps.writer ?? organizationWriter({ dir: configDir(io.env), rolesDir: rolesDir(io.env) });
const verbs = definitionVerbs({ writer, rolesDir: rolesDir(io.env) });
let result;
@@ -93,4 +126,5 @@ export async function definitionsCommand(args, io, deps = {}) {
}
} else throw new CliError(DEFINITIONS_USAGE, 4);
io.stdout.write(JSON.stringify(result, null, 2) + '\n');
}
}
+21 -2
View File
@@ -100,6 +100,15 @@ export function autonomyDocument(current, changes) {
return out;
}
// E2E6 fix 7: the autonomy-precondition check the CLI can see from the read and the document it sent:
// owner notices off while a class sits near the loop, or moves away from the loop.
const ORDER = ['in the loop', 'near the loop', 'out of the loop'];
export function preconditionSeen(current, doc) {
if (doc?.notices === true) return undefined;
const moved = CLASSES.filter(c => ORDER.indexOf(doc?.[c]) > ORDER.indexOf(current?.levels?.[c] ?? 'in the loop'));
if (CLASSES.some(c => doc?.[c] === 'near the loop') || moved.length) return 'owner notices are off; a class near the loop, or one moving away from it, needs them on (--notices on)';
return undefined;
}
// Autonomy codes carry no message from the route; these are the panel's own words (autonomy.js).
const AUTONOMY_GUIDANCE = {
'revision-conflict': 'the organization changed; read it again with mosaic org autonomy ID',
@@ -117,6 +126,10 @@ function refused(answer, what, unknown, guidance = {}) {
const code = typeof raw === 'string' && /^[a-z-]{1,64}$/.test(raw) ? raw : `http ${answer.status}`;
if (code === 'outcome-unknown' || (answer.status >= 500 && !raw)) return new CliError(`outcome unknown: ${unknown}`, 1);
const said = typeof answer.body?.message === 'string' ? answer.body.message.slice(0, 500) : guidance[code];
// E2E6 fix 7: a route that forwards the bus's reason (which check failed) has it said first; the
// general guidance becomes the next line. A reason is one printable line, never a control byte.
const reason = typeof answer.body?.reason === 'string' && /^[\x20-\x7e]{1,300}$/.test(answer.body.reason) ? answer.body.reason : undefined;
if (reason) return new CliError(`${what} refused (${code}): ${reason}`, 3, { next: said });
return new CliError(`${what} refused (${code})${said ? `: ${said}` : ''}`, 3);
}
@@ -173,8 +186,14 @@ export async function orgOwnerCommand(args, io, deps = {}) {
const read = await consoleOrgRequest(ctx, id, { path: 'autonomy' });
if (!ok(read)) throw refused(read, 'autonomy set', 'the autonomy read did not finish; nothing was changed', AUTONOMY_GUIDANCE);
const unknown = `the setting may have been saved; check mosaic org autonomy ${id} before trying again`;
const answer = await consoleOrgRequest(ctx, id, { method: 'POST', path: 'autonomy', body: { revision, autonomy: autonomyDocument(read.body, changes) }, unknown });
if (!ok(answer)) throw refused(answer, 'autonomy set', unknown, AUTONOMY_GUIDANCE);
const doc = autonomyDocument(read.body, changes);
const answer = await consoleOrgRequest(ctx, id, { method: 'POST', path: 'autonomy', body: { revision, autonomy: doc }, unknown });
if (!ok(answer)) {
// E2E6 fix 7: a route that forwards no reason still gets the one check this side can see.
const local = answer.body?.error === 'autonomy-precondition' && answer.body?.reason === undefined ? preconditionSeen(read.body, doc) : undefined;
if (local) throw new CliError(`autonomy set refused (autonomy-precondition): ${local}`, 3, { next: AUTONOMY_GUIDANCE['autonomy-precondition'] });
throw refused(answer, 'autonomy set', unknown, AUTONOMY_GUIDANCE);
}
return { value: answer.body, text: b => `saved autonomy for ${id}: revision ${b.revision ?? 'unknown'}${b.transaction ? `, receipt ${b.transaction}` : ''}\n` };
};
} else if (step === 'review') {
+44 -16
View File
@@ -5,6 +5,7 @@ import { listOrgs, orgLock, resolveOrg } from '../../organization/src/org-regist
import { organizationWriter } from '../../organization/src/organization.mjs';
import { templateRender, validateOrg, createOrg, showOrg, updateOrg, queueInit, queueShow, projectRepoInit, projectRepoShow, projectRepoSet, deleteOrg, archiveOrg, restoreOrg } from '../../organization/src/org-service.mjs';
import { installedStarterPacks } from '../../plugins/src/starter-pack.mjs';
import { appendReceipt } from '../../model-proxy/src/admin.mjs';
import { DEV_OWNER, devOwnerInstance } from './dev-local-owner.mjs';
import { loadSystem, orgPaths, rolesDir } from './config.mjs';
import { CliError } from './errors.mjs';
@@ -15,7 +16,7 @@ import { busExit, humanTransport, refuseInsideAgent } from './transport.mjs';
import { definitionsCommand, DEFINITIONS_USAGE } from './org-definitions.mjs';
import { orgOwnerCommand, ORG_OWNER_USAGE, ORG_OWNER_VERBS } from './org-owner.mjs';
// Starter packs SP4 (design section 8): the owner's pack, board and workflow words.
export const PACKS_USAGE = 'mosaic org pack list | pack preview ID PACK [--project P] [--as KIND.NAME=NEW]... | pack apply ID PACK --digest D [--project P] [--as KIND.NAME=NEW]... | board set ID FILE [--project P] | workflow set ID NAME FILE [--project P] | workflow remove ID NAME [--project P]';
export const PACKS_USAGE = 'mosaic org pack list | pack preview ID PACK [--project P] [--as KIND.NAME=NEW]... | pack apply ID PACK --digest D [--project P] [--as KIND.NAME=NEW]... | pack hire ID PACK [--project P] | board set ID FILE [--project P] | workflow set ID NAME FILE [--project P] | workflow remove ID NAME [--project P]';
// #1873 SP8: saving the organization, or one project, as a template; the owner's alone.
export const TEMPLATE_USAGE = 'mosaic org template save ID NAME [--project P] (--preview | --digest D) | template list ID';
export const ORG_USAGE = 'mosaic org lock show|clear ID | reload ID | archive ID --if-revision N [--json] | restore ID --if-revision N [--no-bus] [--json] | delete ID --confirm ID [--if-revision N] [--json] | template render ID [--fixture local] --output FILE | validate FILE | create ID --from FILE | show ID [--json] | list [--json] | update ID --from FILE --if-revision N | queue init ID (--local-only --accept-local-loss-risk | --remote URL) | queue show ID [--json] | project repo init ID PROJECT (--local-only --accept-local-loss-risk | --remote URL) | project repo show ID PROJECT [--json] | project repo set ID PROJECT (--local-only --accept-local-loss-risk | --remote URL) --if-revision N [--json] | ' + DEFINITIONS_USAGE.slice('mosaic org '.length) + ' | ' + ORG_OWNER_USAGE.slice('mosaic org '.length) + ' | ' + PACKS_USAGE.slice('mosaic org '.length) + ' | ' + TEMPLATE_USAGE.slice('mosaic org '.length) + ' | config validate ID | config resolve ID INSTANCE [--project ID]';
@@ -63,7 +64,27 @@ const PACK_REFUSALS = {
'invalid-request': 'the bus refused the request: a bad argument, a project that is not a code project, or a pack that fails the composition check',
'human-required': 'only the organization\'s owner, from a human shell, may do this',
'starter-pack-not-found': 'no installed, shipped or saved pack has that name',
'starter-pack-invalid': 'the pack fails its own checks or the composition check; nothing was written',
'starter-pack-template-changed': 'a template the pack names changed since it was loaded; preview again',
'not-configured': 'this organization\'s bus has no organization writer configured',
// Ruling 2026-11-14: apply and pack hire hire the pack's proposals. These come back as a hire's code.
'pack-not-applied': 'that pack has no packs entry in this organization or project; preview and apply it first',
'pack-hire-route-missing': 'neither the chief of staff nor the assistant has a harness and model to give a hire; set both in either one\'s vars, then run pack hire',
'no-chief-of-staff': 'the organization has no chief of staff to raise its hires',
'right-required': 'hiring needs the org.hire right',
};
// E2E6 fix 3: humanTransport throws a CliError whose message and .code are the bus code alone. A code
// a table knows gains its hint, as template save's do; a next line it carried is kept. Any other
// CliError (bus-not-running with its own next line, a usage error) passes unchanged, and a bare coded
// error (a test's call) becomes a CliError named by its code.
function hinted(e, ...tables) {
const code = typeof e?.code === 'string' ? e.code : '';
const table = tables.find(t => Object.hasOwn(t, code));
if (!table && (code === '' || e instanceof CliError)) return e;
const error = new CliError(table ? `${code}: ${table[code]}` : code, busExit(code), { next: e.next });
error.code = code;
return error;
}
async function packsCommand(args, io, deps) {
const pos = [], values = {}, as = [];
for (let i = 0; i < args.length; i++) {
@@ -86,6 +107,9 @@ async function packsCommand(args, io, deps) {
if (sub === 'apply' && !values['--digest']) throw new CliError('--digest is required: apply the digest a preview printed', 4);
verb = `pack.${sub}`;
request = { pack: name, ...project, ...(as.length ? { as } : {}), ...(sub === 'apply' ? { digest: values['--digest'] } : {}) };
} else if (word === 'pack' && sub === 'hire' && pos.length === 4) {
// Ruling 2026-11-14: hire the proposals of a pack already applied, the same loop apply runs.
allowed('--project'); verb = 'pack.hire'; request = { pack: name, ...project };
} else if (word === 'board' && sub === 'set' && pos.length === 4) { allowed('--project'); verb = 'board.set'; revised = true; request = { board: await packFile(name), ...project }; }
else if (word === 'workflow' && sub === 'set' && pos.length === 5) { allowed('--project'); verb = 'workflow.set'; revised = true; request = { name, workflow: await packFile(file), ...project }; }
else if (word === 'workflow' && sub === 'remove' && pos.length === 4) { allowed('--project'); verb = 'workflow.set'; revised = true; request = { name, workflow: null, ...project }; }
@@ -105,13 +129,7 @@ async function packsCommand(args, io, deps) {
}
let result;
try { result = await call(verb, request); }
catch (e) {
if (typeof e?.code !== 'string' || e.code === '' || e instanceof CliError) throw e;
const why = PACK_REFUSALS[e.code];
const error = new CliError(why ? `${e.code}: ${why}` : e.code, busExit(e.code));
error.code = e.code;
throw error;
}
catch (e) { throw hinted(e, PACK_REFUSALS); }
io.stdout.write(JSON.stringify(result, null, 2) + '\n');
}
// #1873 SP8: template save previews (--preview) or writes the previewed JSON (--digest); template
@@ -120,7 +138,8 @@ async function packsCommand(args, io, deps) {
const TEMPLATE_REFUSALS = {
'template-secret-suspected': 'a field the template would keep holds a credential the organization\'s bus holds; remove it and preview again (nothing was written)',
'pack-plan-stale': 'the organization or a template changed since the preview; preview again and save its digest',
'invalid-request': 'the bus refused the request: a bad name, a name already saved, an unknown project, or an organization the template cannot hold',
'template-exists': 'a template of this name is already saved for your account; nothing was written',
'invalid-request': 'the bus refused the request: a bad name, an unknown project, or an organization the template cannot hold',
'human-required': 'only the organization\'s owner, from a human shell, may do this',
'not-configured': 'the templates directory is missing or not private to this instance\'s user',
'starter-pack-invalid': 'the template would not be a valid pack: more than 8 hires, or a definition wider than its template',
@@ -147,17 +166,26 @@ async function templateCommand(args, io, deps) {
let result;
try { result = await packCall(id, io, deps)(verb, request); }
catch (e) {
// humanTransport throws a CliError named by the bus code alone: a known code gains its hint.
const why = typeof e?.code !== 'string' ? undefined
: Object.hasOwn(TEMPLATE_REFUSALS, e.code) ? TEMPLATE_REFUSALS[e.code] : Object.hasOwn(PACK_REFUSALS, e.code) ? PACK_REFUSALS[e.code] : undefined;
if (!why) throw e;
const error = new CliError(`${e.code}: ${why}`, busExit(e.code));
error.code = e.code;
const error = hinted(e, TEMPLATE_REFUSALS, PACK_REFUSALS);
// E2E6 fix 8: a taken name says what to do next.
if (error.code === 'template-exists' && error.next === undefined) error.next = `preview and save under another name, or see the saved names with mosaic org template list ${id}`;
throw error;
}
io.stdout.write(JSON.stringify(result, null, 2) + '\n');
}
const busStartVerb = id => `mosaic bus start ${id} --dev-local-owner --detach`;
// #1873 ride-default: `mosaic org update` that takes cliproxy off an organization records the removal
// in the instance's proxy receipts first, where Ride all reads it, as the Console's admin save does.
// A record that cannot be written refuses the update and writes nothing. A stale revision records
// nothing and is left to updateOrg's own refusal.
const providerList = doc => (Array.isArray(doc?.plugins?.['model-provider']) ? doc.plugins['model-provider'] : []);
export async function orgUpdate(ctx, id, doc, { ifRevision, record = org => appendReceipt(ctx.dataRoot, { time: new Date().toISOString(), op: 'ride-removed', org }) } = {}) {
const shown = await showOrg(ctx, id);
if (shown.revision === ifRevision && providerList(shown.doc).includes('cliproxy') && !providerList(doc).includes('cliproxy')) {
try { await record(id); } catch { throw new CliError('the removal of the model proxy could not be recorded, so nothing was saved', 3); }
}
return updateOrg(ctx, id, doc, { ifRevision });
}
export async function orgCommand(args, io, deps = {}) {
try {
// #1873 T1: the definitions verbs take their own options.
@@ -180,7 +208,7 @@ export async function orgCommand(args, io, deps = {}) {
const instance = devOwnerInstance(io.env); const system = deps.system ?? loadSystem({ env: io.env, instance }); const ctx = { configDir: configDir(io.env), dataRoot: system.dataRoot, instance, principal: DEV_OWNER };
if (words[0] === 'lock' && ['show', 'clear'].includes(words[1]) && words.length === 3) { allowed([], []); result = await orgLock(ctx, words[2], { clear: words[1] === 'clear' }); }
else if (words[0] === 'create' && words.length === 2) { allowed([], ['--from']); result = await createOrg(ctx, words[1], await document(need('--from'))); }
else if (words[0] === 'update' && words.length === 2) { allowed([], ['--from', '--if-revision']); const r = need('--if-revision'); if (!/^[1-9][0-9]*$/.test(r)) throw new CliError('invalid revision', 4); result = await updateOrg(ctx, words[1], await document(need('--from')), { ifRevision: Number(r) }); }
else if (words[0] === 'update' && words.length === 2) { allowed([], ['--from', '--if-revision']); const r = need('--if-revision'); if (!/^[1-9][0-9]*$/.test(r)) throw new CliError('invalid revision', 4); result = await orgUpdate(ctx, words[1], await document(need('--from')), { ifRevision: Number(r) }); }
else if (words[0] === 'archive' && words.length === 2) result = await archiveOrg(ctx, words[1], { ...lifecycle, busStop: busStopForDelete, copyRemote: await (deps.copyRemoteFor ?? copyRemoteFor)(ctx) });
else if (words[0] === 'restore' && words.length === 2) {
const startBus = !p.flags.has('--no-bus');
+13
View File
@@ -41,6 +41,7 @@ const EXIT = {
"tester-required": 3,
"tester-off": 3,
"tester-refused": 3,
"bus-not-running": 3,
"outcome-unknown": 1,
"outcome-unknown-revoked": 1,
"response-too-large": 1,
@@ -51,6 +52,17 @@ export function busExit(code) {
return EXIT[code] ?? 2;
}
// E2E6 fix 6: the shim exits 5 (packages/bus/src/client.mjs NOT_SENT_EXIT) when its connect failed
// before the request was written: no socket, or the connect refused. That is a stopped bus, and
// nothing happened; outcome-unknown stays for a request that left and got no answer.
const NOT_SENT_EXIT = 5;
export function busNotRunning(business) {
const error = new CliError(`bus-not-running: the bus for ${business} is not running, so the request was not sent`, 3);
error.code = "bus-not-running";
error.next = `start it with mosaic bus start ${business}, or clear a host that died with mosaic bus recover ${business}`;
return error;
}
// Returns a call(verb, args) for one business. `cli` and `spawn` exist for
// the tests; the command line never sets them.
export function humanTransport({ socket, business, env = process.env, cli = HUMAN_CLI, spawn = spawnSync, timeoutMs = 30000 }) {
@@ -65,6 +77,7 @@ export function humanTransport({ socket, business, env = process.env, cli = HUMA
if (proc.error || proc.status === null) throw new CliError("outcome-unknown: the bus transport did not finish", 1);
if (proc.status !== 0) {
const code = String(proc.stderr ?? "").trim().split("\n").reverse().find((l) => /^[a-z-]{1,64}$/.test(l)) ?? "invalid-response";
if (proc.status === NOT_SENT_EXIT && code === "outcome-unknown") throw busNotRunning(business);
const error = new CliError(code, busExit(code));
error.code = code;
throw error;
+117
View File
@@ -0,0 +1,117 @@
// #1873 triage-wiring: the Triage key file's reader, moved out of triage-key.mjs so the Console can
// read the key at each Triage spawn without loading the proxy management client or the proxy lock.
// It imports node built-ins only; packages/webui/tests/triage-wiring.test.mjs fails if the Console's
// Triage modules load model-proxy/src/client.mjs. triage-key.mjs (the owner's key verbs) imports
// these and re-exports what it exported before, so its callers are unchanged.
//
// <configDir>/secrets/triage/model (directory 0700, file 0600, the running user's)
// { version, key, keyId, issuedAt, rotateBy, retiring: [{ key, keyId, issuedAt, retireAt }] }
//
// Messages name files, never values.
import { closeSync, constants, fchmodSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync } from "node:fs";
import { createHash } from "node:crypto";
import { join } from "node:path";
export const KEY_VERSION = 1;
const FIELDS = Object.freeze(["version", "key", "keyId", "issuedAt", "rotateBy", "retiring"]);
const RETIRING_FIELDS = Object.freeze(["key", "keyId", "issuedAt", "retireAt"]);
const MAX_BYTES = 64 * 1024;
export const MAX_RETIRING = 16;
export const SECRET = /^[A-Za-z0-9_-]{43}$/;
const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
const DAY = /^\d{4}-\d{2}-\d{2}$/;
export class TriageKeyError extends Error {
constructor(code, message, exitCode = 3) {
super(message);
this.name = "TriageKeyError";
this.code = code;
this.exitCode = exitCode;
}
}
export const unreadable = (why) => new TriageKeyError("triage-key-unreadable", `the Triage key store is unreadable: ${why}`);
export const keyIdOf = (key) => createHash("sha256").update(key).digest("hex").slice(0, 12);
export const instanceTag = (configDir) => createHash("sha256").update(configDir).digest("hex").slice(0, 12);
export const keyPrefix = (configDir) => `mst-${instanceTag(configDir)}-triage-`;
const ownKey = (configDir) => (k) => typeof k === "string" && k.startsWith(keyPrefix(configDir)) && SECRET.test(k.slice(keyPrefix(configDir).length));
export function keyPaths(configDir) {
const secrets = join(configDir, "secrets");
const dir = join(secrets, "triage");
return { secrets, dir, file: join(dir, "model") };
}
const plain = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
const exactKeys = (v, keys) => plain(v) && Object.keys(v).length === keys.length && keys.every((k) => Object.hasOwn(v, k));
const canonicalTime = (s) => typeof s === "string" && ISO.test(s) && !Number.isNaN(Date.parse(s)) && new Date(s).toISOString() === s;
const canonicalDay = (s) => typeof s === "string" && DAY.test(s) && !Number.isNaN(Date.parse(`${s}T00:00:00Z`)) && new Date(`${s}T00:00:00Z`).toISOString().slice(0, 10) === s;
export function validRecord(doc, configDir) {
const own = ownKey(configDir);
return exactKeys(doc, FIELDS)
&& doc.version === KEY_VERSION
&& own(doc.key) && doc.keyId === keyIdOf(doc.key)
&& canonicalTime(doc.issuedAt) && canonicalDay(doc.rotateBy)
&& Array.isArray(doc.retiring) && doc.retiring.length <= MAX_RETIRING
&& doc.retiring.every((r) => exactKeys(r, RETIRING_FIELDS) && own(r.key) && r.key !== doc.key && r.keyId === keyIdOf(r.key)
&& canonicalTime(r.issuedAt) && canonicalTime(r.retireAt))
&& new Set(doc.retiring.map((r) => r.key)).size === doc.retiring.length;
}
const uidOf = (opts) => opts.uid ?? process.getuid();
// A real directory, the running user's, mode 0700. Missing: false, or made when `create` is on.
export function checkDir(dir, uid, what, { create }) {
let st;
try { st = lstatSync(dir); }
catch (e) {
if (e.code !== "ENOENT") throw unreadable(`${what} cannot be read`);
if (!create) return false;
try { mkdirSync(dir, { mode: 0o700 }); } catch { throw unreadable(`${what} cannot be made`); }
try {
const fd = openSync(dir, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
try { fchmodSync(fd, 0o700); } finally { closeSync(fd); }
} catch { throw unreadable(`${what} cannot be made`); }
st = lstatSync(dir);
}
if (st.isSymbolicLink()) throw unreadable(`${what} is a link`);
if (!st.isDirectory()) throw unreadable(`${what} is not a directory`);
if (st.uid !== uid) throw unreadable(`${what} is not owned by this user`);
if ((st.mode & 0o777) !== 0o700) throw unreadable(`${what} mode is not 0700`);
return true;
}
export function checkFile(fd, uid, what, fail = unreadable) {
const st = fstatSync(fd);
if (!st.isFile()) throw fail(`${what} is not a regular file`);
if (st.nlink !== 1) throw fail(`${what} has more than one link`);
if (st.uid !== uid) throw fail(`${what} is not owned by this user`);
if ((st.mode & 0o777) !== 0o600) throw fail(`${what} mode is not 0600`);
return st;
}
// The stored record, or null when no key is issued. Throws triage-key-unreadable on anything unsafe.
// opts.uid (both directories and the file) and opts.fileUid (the file only) are test seams for the
// owner checks.
export function readKey(configDir, opts = {}) {
const { secrets, dir, file } = keyPaths(configDir);
const uid = uidOf(opts);
if (!checkDir(secrets, uid, "the secrets directory", { create: false })) return null;
if (!checkDir(dir, uid, "the triage secrets directory", { create: false })) return null;
let fd;
try { fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK); }
catch (e) {
if (e.code === "ENOENT") return null;
if (e.code === "ELOOP") throw unreadable("the key file is a link");
throw unreadable("the key file cannot be opened");
}
try {
const st = checkFile(fd, opts.fileUid ?? uid, "the key file");
if (st.size > MAX_BYTES) throw unreadable("the key file is too large");
let doc;
try { doc = JSON.parse(readFileSync(fd, "utf8")); } catch { throw unreadable("the key file is not JSON"); }
if (!validRecord(doc, configDir)) throw unreadable("the key file does not match the key shape");
return doc;
} finally { closeSync(fd); }
}
+294
View File
@@ -0,0 +1,294 @@
// #1873 triage-key: Triage's own model proxy client key, issued from the owner's terminal
// (design report reports/triage-route-design.md slice 3, Jason's ruling 2026-11-18).
//
// <configDir>/secrets/triage/model (directory 0700, file 0600, the running user's)
// { version, key, keyId, issuedAt, rotateBy, retiring: [{ key, keyId, issuedAt, retireAt }] }
//
// The key is `mst-<instance tag>-triage-<43 base64url>`, where the tag is the first 12 hex of
// sha256(configDir), the tag the instance's own `msk-` sentinel carries. An org bus reconciles only
// its own `mso-<tag>-<org>-key-` names and a no-org bus only `msk-<tag>-`, so neither touches it.
//
// Every proxy write runs under the instance proxy lock (packages/bus/src/proxy-lock.mjs), the lock
// org buses take: read the list, check this instance's sentinel, fence, PUT, read back, confirm.
// The proxy changes first and the file second, as the bus does for an agent key. A crash between
// leaves a key in the Triage namespace that the file does not hold; the next issue, rotate or retire
// removes it, and status names it. A crash after the PUT and before the read-back leaves the lock's
// uncertain fence, which every proxy writer on the instance refuses until a human clears it
// (`mosaic proxy fence clear --proxy-restarted`).
//
// Nothing runs on a timer. rotate records when the old key's grace ends; the key stays in the proxy
// until a later retire, rotate or issue removes it, and status says when that is due. The same goes
// for rotateBy: status marks it due; only rotate replaces the key.
//
// Nothing here prints, logs or records a key. Receipts and output carry key ids only (the first 12
// hex of sha256(key), the id the bus uses). Messages name files and options, never values.
// The Console reads the key at each Triage spawn through triage-key-file.mjs, never this module.
import { closeSync, constants, fchmodSync, fsyncSync, lstatSync, openSync, readdirSync, renameSync, unlinkSync, writeSync } from "node:fs";
import { randomBytes } from "node:crypto";
import { join } from "node:path";
import { isDeepStrictEqual } from "node:util";
import { createProxyLock } from "../../bus/src/proxy-lock.mjs";
import { loadManagementClient } from "../../model-proxy/src/client.mjs";
// #1873 triage-wiring: the key file's reader lives in triage-key-file.mjs (node built-ins only), so
// the Console reads the key without this module's proxy client. Re-exported here unchanged.
import { KEY_VERSION, MAX_RETIRING, SECRET, TriageKeyError, checkDir, checkFile, instanceTag, keyIdOf, keyPaths, keyPrefix, readKey, unreadable, validRecord } from "./triage-key-file.mjs";
export { KEY_VERSION, TriageKeyError, instanceTag, keyIdOf, keyPaths, keyPrefix, readKey, validRecord };
// The org key lifetime and the rotate grace default. The bus holds both as literals
// (packages/bus/src/model-keys.mjs #issue: 30 days to rotateBy; packages/bus/src/runtime.mjs:
// `proxy.rotateGraceMinutes ?? 120`) and exports neither, and this lane may not change the bus.
// packages/cli/tests/triage-key.test.mjs drives the bus's own ModelKeys with the same clock and
// proves these give the same rotateBy and retireAt, so a change on either side goes red there.
// The grace itself is read from proxy.json first, where the bus reads it.
export const KEY_LIFETIME_DAYS = 30;
export const DEFAULT_ROTATE_GRACE_MINUTES = 120;
const sentinelPrefix = (configDir) => `msk-${instanceTag(configDir)}-sentinel-`;
// Any name under the prefix is Triage's to remove, well formed or not, as the bus treats its own
// `msk-<tag>-` names. Only a well-formed key may be stored in the file.
const inNamespace = (configDir) => (k) => typeof k === "string" && k.startsWith(keyPrefix(configDir));
// Both directories, checked (and the triage one made) before any proxy write, so a store that cannot
// be written refuses while the proxy is still untouched.
function prepareDirs(configDir, uid) {
const { secrets, dir } = keyPaths(configDir);
if (!checkDir(secrets, uid, "the secrets directory", { create: false })) throw unreadable("the secrets directory is missing");
checkDir(dir, uid, "the triage secrets directory", { create: true });
}
// A temp file writeKey left when it was killed before its rename. It may hold a key.
const TEMP = /^\.model\.\d+\.[0-9a-f]{12}\.tmp$/;
const tempsIn = (dir) => { try { return readdirSync(dir).filter((n) => TEMP.test(n)); } catch { return []; } };
// Under the lock no other Triage writer runs, so every temp file left in the directory is dead.
function removeTemps(configDir) {
const { dir } = keyPaths(configDir);
for (const name of tempsIn(dir)) {
try { if (!lstatSync(join(dir, name)).isDirectory()) unlinkSync(join(dir, name)); }
catch { throw unreadable("a leftover temp file in the triage secrets directory cannot be removed"); }
}
}
// A directory sync that failed after the rename: the file is in place but may not be durable.
class NotSynced extends Error {}
// Atomic: a 0600 temp file in the same directory, fsync, rename, fsync of the directory.
function writeKey(configDir, record, uid, hook = () => {}) {
const { dir, file } = keyPaths(configDir);
prepareDirs(configDir, uid);
const temp = join(dir, `.model.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
let fd;
try { fd = openSync(temp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600); }
catch { throw unreadable("the key file cannot be written"); }
try {
try { fchmodSync(fd, 0o600); writeSync(fd, `${JSON.stringify(record, null, 2)}\n`); fsyncSync(fd); }
finally { closeSync(fd); }
hook("rename");
renameSync(temp, file);
} catch { try { unlinkSync(temp); } catch {} throw unreadable("the key file cannot be written"); }
try {
hook("sync");
const dfd = openSync(dir, constants.O_RDONLY | constants.O_DIRECTORY);
try { fsyncSync(dfd); } finally { closeSync(dfd); }
} catch { throw new NotSynced(); }
}
// One line per write in the proxy lock's receipts file, ids only. `receiptsReady` runs under the
// lock before any change, so an unsafe receipts file refuses while nothing has changed yet.
const RECEIPTS_FLAGS = constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW | constants.O_NONBLOCK;
const receiptsUnsafe = (why) => new TriageKeyError("triage-key-receipts-unsafe", `${why}; nothing was changed`);
function receiptsReady(stateDir, uid) {
let fd;
try { fd = openSync(join(stateDir, "mosaic-keys.receipts.jsonl"), RECEIPTS_FLAGS, 0o600); }
catch { throw receiptsUnsafe("the proxy receipts file cannot be opened"); }
try { checkFile(fd, uid, "the proxy receipts file", receiptsUnsafe); } finally { closeSync(fd); }
}
function receipt(stateDir, uid, entry) {
const unrecorded = new TriageKeyError("triage-key-unrecorded", "the change was made but its receipt line was not written; run mosaic triage key status");
let fd;
try { fd = openSync(join(stateDir, "mosaic-keys.receipts.jsonl"), RECEIPTS_FLAGS, 0o600); } catch { throw unrecorded; }
try {
checkFile(fd, uid, "the proxy receipts file", () => unrecorded);
writeSync(fd, `${JSON.stringify(entry)}\n`);
fsyncSync(fd);
} catch { throw unrecorded; }
finally { closeSync(fd); }
}
// The grace the bus uses: proxy.json's rotateGraceMinutes, or the bus default.
export const graceMinutes = (proxy) => proxy?.rotateGraceMinutes ?? DEFAULT_ROTATE_GRACE_MINUTES;
export const rotateByFor = (nowMs) => new Date(nowMs + KEY_LIFETIME_DAYS * 86400_000).toISOString().slice(0, 10);
export const retireAtFor = (nowMs, proxy) => new Date(nowMs + graceMinutes(proxy) * 60_000).toISOString();
const proxyFailure = (code) => {
const words = {
"proxy-lock-busy": "another proxy writer holds the instance proxy lock; try again when it ends, and if no writer is running, see mosaic proxy fence status",
"proxy-lock-uncertain": "the instance proxy lock is in a state this verb will not guess about; check <dataRoot>/proxy by hand",
"proxy-lock-invalid": "the instance proxy lock directory is missing or unsafe, or names another proxy",
"proxy-uncertain": "an earlier proxy write has an uncertain outcome; see mosaic proxy fence status",
"proxy-management-key-invalid": "the proxy management key file is missing or unsafe",
"proxy-client-invalid": "the proxy settings are not usable",
"proxy-client-down": "the proxy did not answer",
"proxy-client-refused": "the proxy refused the management request",
"proxy-client-redirect": "the proxy answered with a redirect",
"proxy-client-response": "the proxy gave an answer this verb cannot use",
};
return new TriageKeyError(code, words[code] ?? "the proxy write failed");
};
// opts.uid, opts.now and opts.hook(stage) are test seams; a stage hook may throw or kill the process.
function context({ configDir, system, uid, fileUid, now, hook }) {
if (!system?.proxy || !Number.isInteger(system.proxy.port)) throw new TriageKeyError("triage-key-no-proxy", "the instance has no model proxy set up (proxy.json)");
return {
configDir, dataRoot: system.dataRoot, proxy: system.proxy, stateDir: join(system.dataRoot, "proxy"),
uid: uid ?? process.getuid(), fileUid, now: now ?? Date.now, hook: hook ?? (() => {}),
};
}
function lockFor(c) {
try { return createProxyLock({ stateDir: c.stateDir, identity: `${c.configDir}:${c.proxy.port}` }); }
catch (e) { throw proxyFailure(e.code ?? "proxy-lock-invalid"); }
}
async function clientFor(c) {
try { return await loadManagementClient({ configDir: c.configDir, proxy: c.proxy }); }
catch (e) { throw proxyFailure(e.code ?? "proxy-management-key-invalid"); }
}
function checkSentinel(c, keys) {
const prefix = sentinelPrefix(c.configDir);
if (!keys.some((k) => k.startsWith(prefix) && SECRET.test(k.slice(prefix.length)))) {
throw new TriageKeyError("triage-key-proxy-open", "the proxy's key list has no sentinel for this instance, so it may be another proxy");
}
}
// Under the instance proxy lock: read the list, check the sentinel, run `plan`, write the result.
// `plan(keys, record)` returns { after, record, removed, added, done }; `record` null leaves the
// file alone. The proxy changes first, then the file, then one receipt line.
async function change(c, op, plan) {
const lock = lockFor(c);
const client = await clientFor(c);
try {
return await lock.run(async () => {
const before = await client.getKeys();
checkSentinel(c, before);
const current = readKey(c.configDir, { uid: c.uid, fileUid: c.fileUid });
const result = plan(before, current);
if (result.record) prepareDirs(c.configDir, c.uid);
removeTemps(c.configDir);
receiptsReady(c.stateDir, c.uid);
const after = result.after;
const removed = before.filter((k) => !after.includes(k));
const added = after.filter((k) => !before.includes(k));
// A key in another namespace never leaves the list.
if (removed.some((k) => !inNamespace(c.configDir)(k))) throw new TriageKeyError("triage-key-failed", "the change would remove a key outside the Triage namespace");
if (added.length || removed.length) {
// As the bus does: a list that moved since the first read is not overwritten.
if (!isDeepStrictEqual(await client.getKeys(), before)) throw new TriageKeyError("triage-key-raced", "the proxy's key list changed while this verb ran; run it again");
lock.fence({ org: null, op: `triage.${op}` });
await client.putKeys(after);
c.hook("put");
const confirmed = await client.getKeys();
if (!confirmed.some((k) => k.startsWith(sentinelPrefix(c.configDir))) || added.some((k) => !confirmed.includes(k)) || removed.some((k) => confirmed.includes(k))) {
throw new TriageKeyError("triage-key-unconfirmed", "the proxy did not confirm the change; the instance proxy fence stays set, see mosaic proxy fence status");
}
lock.confirm();
}
c.hook("write");
let unsynced = false;
if (result.record) {
try { writeKey(c.configDir, result.record, c.uid, c.hook); }
catch (e) {
if (e instanceof NotSynced) unsynced = true;
else throw new TriageKeyError("triage-key-unwritten", `the proxy list changed but ${keyPaths(c.configDir).file} was not written (${e.message}); fix the file's directory, then run mosaic triage key ${op} again, which clears what this run left`);
}
}
c.hook("receipt");
// A run that changed neither the proxy nor the file leaves no receipt.
if (added.length || removed.length || result.record) receipt(c.stateDir, c.uid, { op: `triage.key.${op}`, time: new Date(c.now()).toISOString(), addedKeyIds: added.map(keyIdOf), removedKeyIds: removed.map(keyIdOf) });
// The file is in place and the receipt written; only its durability is in doubt.
if (unsynced) throw new TriageKeyError("triage-key-unsynced", `${keyPaths(c.configDir).file} was written but its directory could not be synced, so it may not survive a power loss; run mosaic triage key status`);
return { ...result.done, addedKeyIds: added.map(keyIdOf), removedKeyIds: removed.map(keyIdOf) };
});
} catch (e) {
if (e instanceof TriageKeyError) throw e;
throw proxyFailure(typeof e?.code === "string" && /^proxy-[a-z-]+$/.test(e.code) ? e.code : "triage-key-failed");
}
}
const newKey = (configDir) => keyPrefix(configDir) + randomBytes(32).toString("base64url");
// Keys in the Triage namespace that the file does not hold: left by a crash between the PUT and the
// file write, or by a file that was removed by hand.
const orphansOf = (configDir, keys, record) => {
const held = record ? [record.key, ...record.retiring.map((r) => r.key)] : [];
return keys.filter((k) => inNamespace(configDir)(k) && !held.includes(k));
};
export async function issueKey(opts) {
const c = context(opts);
return change(c, "issue", (before, current) => {
if (current) throw new TriageKeyError("triage-key-issued", "a Triage key is already issued; use mosaic triage key rotate");
const orphans = orphansOf(c.configDir, before, null);
const key = newKey(c.configDir), nowMs = c.now();
const record = { version: KEY_VERSION, key, keyId: keyIdOf(key), issuedAt: new Date(nowMs).toISOString(), rotateBy: rotateByFor(nowMs), retiring: [] };
return { after: [...before.filter((k) => !orphans.includes(k)), key], record, done: { keyId: record.keyId, rotateBy: record.rotateBy } };
});
}
// Retiring keys whose grace has passed, or that the proxy no longer holds.
const dueOf = (record, keys, nowMs) => record.retiring.filter((r) => Date.parse(r.retireAt) <= nowMs || !keys.includes(r.key));
export async function rotateKey(opts) {
const c = context(opts);
return change(c, "rotate", (before, current) => {
if (!current) throw new TriageKeyError("triage-key-not-issued", "no Triage key is issued; use mosaic triage key issue");
const nowMs = c.now();
const orphans = orphansOf(c.configDir, before, current);
const due = dueOf(current, before, nowMs);
const keep = before.includes(current.key);
const retiring = [...current.retiring.filter((r) => !due.includes(r)),
...(keep ? [{ key: current.key, keyId: current.keyId, issuedAt: current.issuedAt, retireAt: retireAtFor(nowMs, c.proxy) }] : [])];
if (retiring.length > MAX_RETIRING) throw new TriageKeyError("triage-key-failed", "too many keys are retiring; run mosaic triage key retire once their grace has passed");
const key = newKey(c.configDir);
const record = { version: KEY_VERSION, key, keyId: keyIdOf(key), issuedAt: new Date(nowMs).toISOString(), rotateBy: rotateByFor(nowMs), retiring };
const drop = [...orphans, ...due.map((r) => r.key)];
return {
after: [...before.filter((k) => !drop.includes(k)), key], record,
done: { keyId: record.keyId, rotateBy: record.rotateBy, old: keep ? { keyId: current.keyId, retireAt: retiring.at(-1).retireAt } : { keyId: current.keyId, lost: true } },
};
});
}
export async function retireKeys(opts) {
const c = context(opts);
return change(c, "retire", (before, current) => {
const nowMs = c.now();
const orphans = orphansOf(c.configDir, before, current);
const due = current ? dueOf(current, before, nowMs) : [];
const record = current && due.length ? { ...current, retiring: current.retiring.filter((r) => !due.includes(r)) } : null;
const drop = [...orphans, ...due.map((r) => r.key)];
return { after: before.filter((k) => !drop.includes(k)), record, done: { droppedKeyIds: due.map((r) => r.keyId) } };
});
}
// Read only: the file, and when the proxy is set up, what its list holds. No lock, no write.
// The fence is checked by name only, so status writes nothing, not even the lock's identity file.
export async function keyStatus(opts) {
const { configDir, system, uid, fileUid } = opts;
const record = readKey(configDir, { uid, fileUid });
const proxy = { state: "not-set-up", fence: false, leftoverTemps: tempsIn(keyPaths(configDir).dir).length };
if (system?.proxy && Number.isInteger(system.proxy.port)) {
try { lstatSync(join(system.dataRoot, "proxy", "mosaic-keys.uncertain")); proxy.fence = true; }
catch (e) { if (e.code !== "ENOENT") proxy.fence = true; }
try {
const client = await loadManagementClient({ configDir, proxy: system.proxy });
const keys = await client.getKeys();
const prefix = sentinelPrefix(configDir);
proxy.state = keys.some((k) => k.startsWith(prefix) && SECRET.test(k.slice(prefix.length))) ? "read" : "no-sentinel";
proxy.holdsKey = record ? keys.includes(record.key) : null;
proxy.retiringHeld = record ? record.retiring.map((r) => keys.includes(r.key)) : [];
proxy.orphanKeyIds = orphansOf(configDir, keys, record).map(keyIdOf);
} catch (e) { proxy.state = "unreadable"; proxy.code = typeof e?.code === "string" && /^proxy-[a-z-]+$/.test(e.code) ? e.code : "proxy-client-response"; }
}
return { record, proxy };
}
+188
View File
@@ -0,0 +1,188 @@
// #1873 triage-route-store: the owner's terminal verbs for the Triage route file,
// <dataRoot>/triage/route.json (packages/webui/src/triage-route-store.mjs).
//
// mosaic triage route show
// mosaic triage route set --model KEY --harness NAME --cap TOKENS --time-zone ZONE [--revision N]
//
// Both are human verbs: an agent run is refused before anything is read (exit 3), from this
// process's environment and the one the command was given, as the bus and Console lifecycle verbs
// refuse it. `show` with no file prints "not set" and exits 0. Without --revision a write
// compares with the revision read under the store's lock; pass --revision from `show` to make the
// write conditional on what was shown (0: only when no route is set yet).
//
// Nothing here wires the route into the Triage host: the Console keeps `route: null` until the
// wiring slice. `set` checks the harness against the repository's harness modules; it does not
// check the model key against a catalogue, since none exists outside an organization's bus yet.
//
// mosaic triage key issue | rotate | retire | status
//
// Triage's own model proxy client key (packages/cli/src/triage-key.mjs). Human verbs as well,
// refused in an agent run before anything is read. No output names a key, only its id.
import { lstatSync } from "node:fs";
import { join } from "node:path";
import { fileURLToPath } from "node:url";
import { readRoute, RouteStoreError, writeRoute } from "../../webui/src/triage-route-store.mjs";
import { loadSystem } from "./config.mjs";
import { configDir } from "../../organization/src/organization-config.mjs";
import { issueKey, keyPaths, keyStatus, retireKeys, rotateKey, TriageKeyError } from "./triage-key.mjs";
import { CliError } from "./errors.mjs";
import { refuseInsideAgent } from "./transport.mjs";
export const TRIAGE_USAGE = "mosaic triage route show | set --model KEY --harness NAME --cap TOKENS --time-zone ZONE [--revision N] | key issue | rotate | retire | status";
const KEY_VERBS = ["issue", "rotate", "retire", "status"];
const HARNESS_ROOT = fileURLToPath(new URL("../../plugins/harness/", import.meta.url));
const VALUES = ["--model", "--harness", "--cap", "--time-zone", "--revision"];
const WHOLE = /^(0|[1-9][0-9]*)$/;
// The actor every terminal write records: the instance owner, the only person who runs this verb.
const ACTOR = "owner";
const usage = (why) => new CliError(`${why}\nusage: ${TRIAGE_USAGE}`, 4);
// Option names, never values, in a refusal.
function parse(args) {
const values = {}, positional = [];
for (let i = 0; i < args.length; i++) {
const a = args[i];
if (VALUES.includes(a)) {
if (i + 1 >= args.length) throw usage(`${a} needs one value`);
if (Object.hasOwn(values, a)) throw usage(`${a} is given twice`);
values[a] = args[++i];
} else if (a.startsWith("--")) throw usage("unknown option");
else positional.push(a);
}
return { values, positional };
}
function whole(text, name) {
if (!WHOLE.test(text)) throw new CliError(`triage-route-invalid: ${name} must be a whole number`, 2);
return Number(text);
}
function knownHarness(name) {
if (!/^[a-z][a-z0-9-]{0,31}$/.test(name)) return false;
try { return lstatSync(join(HARNESS_ROOT, name, "index.mjs")).isFile(); } catch { return false; }
}
function storeError(error) {
if (!(error instanceof RouteStoreError)) throw error;
return new CliError(`${error.code}: ${error.message}`, error.code === "triage-route-invalid" ? 2 : 3);
}
function show(route) {
if (!route) return "triage route: not set\n";
const { cap } = route;
return [
`triage route: revision ${route.revision}`,
`model: ${route.model}`,
`harness: ${route.harness}`,
`cap: ${cap.limit} tokens a day, resets ${cap.reset} ${cap.timeZone}, counted since ${cap.since}`,
`updated: ${route.updatedAt} by ${route.updatedBy}`,
"",
].join("\n");
}
// A key error prints its code and fixed words. Anything else becomes one fixed line, so no value
// that an unexpected error might carry reaches the terminal.
function keyError(error) {
if (error instanceof CliError) return error;
if (error instanceof TriageKeyError) return new CliError(`${error.code}: ${error.message}`, error.exitCode);
return new CliError("triage-key-failed: the key verb stopped on an unexpected error; run mosaic triage key status", 3);
}
const age = (ms) => {
const m = Math.max(0, Math.floor(ms / 60_000));
return `${Math.floor(m / 1440)}d ${Math.floor((m % 1440) / 60)}h ${m % 60}m`;
};
const ids = (list) => (list.length ? list.join(", ") : "none");
function statusText({ record, proxy }, nowMs, file) {
const lines = [`triage key: ${record ? "issued" : "not issued"}`, `file: ${file}`];
const rotateDue = record && Date.parse(`${record.rotateBy}T00:00:00Z`) <= nowMs;
const retireDue = record ? record.retiring.filter((r) => Date.parse(r.retireAt) <= nowMs) : [];
if (record) {
lines.push(`key id: ${record.keyId}`, `issued: ${record.issuedAt} (age ${age(nowMs - Date.parse(record.issuedAt))})`, `rotate by: ${record.rotateBy}${rotateDue ? " (due)" : ""}`);
record.retiring.forEach((r, i) => {
const held = proxy.retiringHeld?.[i];
lines.push(`retiring: ${r.keyId}, live until a retire after ${r.retireAt}${Date.parse(r.retireAt) <= nowMs ? " (due)" : ""}${held === false ? " (not in the proxy list)" : ""}`);
});
}
const state = {
"not-set-up": "not set up for this instance (no proxy.json)",
"no-sentinel": "its key list has no sentinel for this instance",
unreadable: `not read (${proxy.code})`,
read: record ? (proxy.holdsKey ? "holds the key" : "does not hold the key") : "read",
}[proxy.state];
lines.push(`proxy: ${state}`);
if (proxy.fence) lines.push("proxy fence: set, an earlier proxy write has an uncertain outcome");
if (proxy.leftoverTemps) lines.push(`leftover temp files in the triage secrets directory: ${proxy.leftoverTemps} (the next issue, rotate or retire removes them)`);
if (proxy.orphanKeyIds?.length) lines.push(`keys in the Triage namespace the file does not hold: ${ids(proxy.orphanKeyIds)}`);
let next;
if (proxy.fence) next = "restart the proxy, then mosaic proxy fence clear --proxy-restarted";
else if (proxy.state !== "read") next = proxy.state === "not-set-up" ? "set up the model proxy first (mosaic proxy init)" : "check the proxy with mosaic proxy status";
else if (!record) next = "mosaic triage key issue";
else if (!proxy.holdsKey || rotateDue) next = "mosaic triage key rotate";
else if (retireDue.length || proxy.leftoverTemps || proxy.orphanKeyIds?.length || proxy.retiringHeld?.includes(false)) next = "mosaic triage key retire";
else next = "nothing";
lines.push(`next: ${next}`, "");
return lines.join("\n");
}
async function keyCommand(sub, args, io, deps) {
if (!KEY_VERBS.includes(sub)) throw usage("unknown triage key command");
if (args.length) throw usage(args[0].startsWith("--") ? "unknown option" : "unexpected argument");
try {
const system = deps.system ?? loadSystem({ env: io.env });
const dir = configDir(io.env);
const now = deps.now ? () => deps.now().getTime() : Date.now;
const opts = { configDir: dir, system, now, uid: deps.triageKeyUid, fileUid: deps.triageKeyFileUid, hook: deps.triageKeyHook };
if (sub === "status") {
io.stdout.write(statusText(await keyStatus(opts), now(), keyPaths(dir).file));
return;
}
if (sub === "issue") {
const r = await issueKey(opts);
io.stdout.write(`triage key issued: ${r.keyId}, rotate by ${r.rotateBy}\nfile: ${keyPaths(dir).file}\n`);
if (r.removedKeyIds.length) io.stdout.write(`removed keys this file did not hold: ${ids(r.removedKeyIds)}\n`);
return;
}
if (sub === "rotate") {
const r = await rotateKey(opts);
io.stdout.write(`triage key rotated: ${r.keyId}, rotate by ${r.rotateBy}\n`);
io.stdout.write(r.old.lost
? `old key ${r.old.keyId} was not in the proxy list; nothing to retire\n`
: `old key ${r.old.keyId} stays live until mosaic triage key retire runs at or after ${r.old.retireAt}\n`);
if (r.removedKeyIds.length) io.stdout.write(`removed: ${ids(r.removedKeyIds)}\n`);
return;
}
const r = await retireKeys(opts);
io.stdout.write(r.removedKeyIds.length ? `triage key retire: removed ${ids(r.removedKeyIds)}\n` : "triage key retire: nothing to remove\n");
} catch (e) { throw keyError(e); }
}
export function triageCommand(rest, io, deps = {}) {
refuseInsideAgent(process.env);
refuseInsideAgent(io.env);
const [noun, sub, ...args] = rest;
if (noun === "key" && sub !== undefined) return keyCommand(sub, args, io, deps);
if (noun !== "route" || !["show", "set"].includes(sub)) throw usage("unknown triage command");
const { values, positional } = parse(args);
if (positional.length) throw usage("unexpected argument");
const dataRoot = () => (deps.system ?? loadSystem({ env: io.env })).dataRoot;
if (sub === "show") {
if (Object.keys(values).length) throw usage("show takes no options");
let route;
try { route = readRoute(dataRoot()); } catch (e) { throw storeError(e); }
io.stdout.write(show(route));
return;
}
for (const name of ["--model", "--harness", "--cap", "--time-zone"]) if (!Object.hasOwn(values, name)) throw usage(`set needs ${name}`);
if (!knownHarness(values["--harness"])) throw new CliError("triage-route-invalid: no harness module has that name", 2);
const input = {
model: values["--model"], harness: values["--harness"], limit: whole(values["--cap"], "--cap"),
timeZone: values["--time-zone"], by: ACTOR,
...(Object.hasOwn(values, "--revision") ? { revision: whole(values["--revision"], "--revision") } : {}),
};
let route;
try { route = writeRoute(dataRoot(), input, deps.now ? { now: deps.now } : {}); } catch (e) { throw storeError(e); }
io.stdout.write(`triage route set: revision ${route.revision}\n`);
}
+17
View File
@@ -89,6 +89,8 @@ function organizations({ send = true } = {}) {
calls.push({ verb, args, opts });
if (verb === 'autonomy.review.console') return { reviewed: args.decisionClass };
if (args.revision !== state.revision) throw new BusReadError('revision-conflict');
// E2E6 fix 7: the bus refuses policy out of the loop here; the route forwards the code alone.
if (args.autonomy.policy === 'out of the loop') throw new BusReadError('autonomy-precondition');
const { notices, reverseWindowHours, authorityResolver, ...levels } = args.autonomy;
state = { revision: REV(parseInt(state.revision, 16) + 1), levels, autonomy: { notices, reverseWindowHours, ...(authorityResolver ? { authorityResolver } : {}) } };
return { revision: state.revision, transaction: `tx-${parseInt(state.revision, 16)}` };
@@ -259,6 +261,21 @@ test('autonomy reads, saves with the panel\'s revision check and records a revie
assert.equal((await page(c.port, 'GET', '/api/orgs/alpha/autonomy')).body.revision, REV(5));
c.calls.splice(0);
// E2E6 fix 7: an autonomy-precondition the route sends without a reason still names the one check the
// terminal can see from its read and the document it sent (notices off while a class moves away),
// and the general guidance becomes the next line.
r = await mosaic(env, ['org', 'autonomy', 'alpha', 'set', '--revision', REV(5), '--policy', 'out']);
assert.equal(r.status, 3, r.stderr);
assert.match(r.stderr, /^mosaic: autonomy set refused \(autonomy-precondition\): owner notices are off; a class near the loop, or one moving away from it, needs them on \(--notices on\)$/m);
assert.match(r.stderr, /^mosaic: next: this move needs a separate resolver/m);
const { preconditionSeen } = await import('../src/org-owner.mjs');
const shown = { levels: { ...LOOP, merge: 'near the loop' } };
assert.equal(preconditionSeen(shown, { ...LOOP, merge: 'near the loop', notices: true }), undefined);
assert.equal(preconditionSeen(shown, { ...LOOP, notices: false }), undefined, 'moving back toward the loop needs no notices');
assert.match(preconditionSeen(shown, { ...LOOP, merge: 'near the loop', notices: false }), /^owner notices are off/);
assert.match(preconditionSeen({ levels: LOOP }, { ...LOOP, authority: 'out of the loop', notices: false }), /^owner notices are off/);
c.calls.splice(0);
r = await mosaic(env, ['org', 'autonomy', 'alpha', 'review', 'merge']);
assert.equal(r.status, 0, r.stderr);
assert.equal(r.stdout, 'recorded your trail review for merge on alpha\n');
+9
View File
@@ -67,6 +67,15 @@ test('two organization buses are isolated and refusals never select a sibling',
writeFileSync(join(alpha.root, 'bus-host/host.json'), JSON.stringify(staleHost), { mode: 0o600 });
writeFileSync(join(alpha.root, 'bus-host/host.lock'), JSON.stringify(staleHost), { mode: 0o600 });
writeFileSync(join(alpha.root, 'bus/writer.lock'), JSON.stringify({ pid: 2147483647, at: '2026-01-01T00:00:00Z' }), { mode: 0o600 });
// E2E6 fix 1: status, start, stop and restart refuse a dead host's lock with the message unchanged and a
// next line naming the verb that clears it.
for (const args of [['status', 'alpha', '--json'], ['start', 'alpha', '--no-launch', '--detach'], ['stop', 'alpha'], ['restart', 'alpha']]) {
const r = spawnSync(join(REPO, 'scripts/mosaic'), ['bus', ...args], { env, encoding: 'utf8', timeout: 30000 });
assert.equal(r.status, 3, `${args[0]}: ${r.stderr}`);
assert.match(r.stderr, /^mosaic: stale bus host lock$/m, args[0]);
assert.match(r.stderr, /^mosaic: next: if the bus host died, clear it with mosaic bus recover alpha; recover refuses while the host still runs$/m, args[0]);
}
await assert.rejects(busStatus(ctx, 'alpha'), e => e.message === 'stale bus host lock' && e.exitCode === 3 && /mosaic bus recover alpha/.test(e.next));
const recovery = spawnSync(join(REPO, 'scripts/mosaic'), ['bus', 'recover', 'alpha'], { env, encoding: 'utf8' });
assert.equal(recovery.status, 0, recovery.stderr);
const restarted = await busStart(ctx, 'alpha', { detach: true, noLaunch: true });
+57
View File
@@ -417,3 +417,60 @@ test('a detached console without the dev owner has no supervisor, so it refuses
assert.equal(start.stderr, '');
assert.equal((await consoleStop(ctx)).stopped, true);
});
// E2E6 fix 4: console start and stop clear a start.lock whose named supervisor (pid and start time) is
// gone, and never one whose holder still runs or that names no holder.
test('E2E6 a start.lock whose holder is gone is cleared by stop and by start; a live or unnamed one refuses and stays', { timeout: 60000 }, async t => {
const { startTimeOf } = await import('../src/host.mjs');
const { ctx } = await instance(t);
const dir = join(ctx.dataRoot, 'console'), lock = join(dir, 'start.lock');
mkdirSync(dir, { recursive: true, mode: 0o700 });
// A process this test starts and lets end: its pid and start time name a supervisor that is gone.
const child = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 30000)'], { stdio: 'ignore' });
await new Promise(r => child.once('spawn', r));
const deadHolder = { pid: child.pid, startTime: startTimeOf(child.pid) };
assert.match(deadHolder.startTime, /^\d+$/);
child.kill('SIGKILL');
await new Promise(r => child.once('exit', r));
const warnings = [];
writeFileSync(lock, JSON.stringify(deadHolder), { mode: 0o600 });
assert.deepEqual(await consoleStop(ctx, { warn: s => warnings.push(s) }), { stopped: false });
assert.deepEqual(warnings, [`mosaic: cleared a console start lock left by process ${child.pid}, which is gone\n`]);
assert.equal(existsSync(lock), false);
assert.deepEqual(readdirSync(dir).filter(x => x.startsWith('start.lock')), []);
// A live pid with another start time is a reused pid: its holder is gone too.
writeFileSync(lock, JSON.stringify({ pid: process.pid, startTime: '1' }), { mode: 0o600 });
warnings.length = 0;
const result = await consoleStart(ctx, { detach: true, port: 'auto', warn: s => warnings.push(s) });
assert.deepEqual(warnings, [`mosaic: cleared a console start lock left by process ${process.pid}, which is gone\n`]);
assert.equal(existsSync(lock), false, 'the start released its own lock');
assert.equal((await consoleStop(ctx)).stopped, true);
assert.ok(Number.isSafeInteger(result.pid));
// A live holder refuses on start and stop, and the lock stays as it was.
const live = JSON.stringify({ pid: process.pid, startTime: startTimeOf(process.pid) });
writeFileSync(lock, live, { mode: 0o600 });
await assert.rejects(consoleStop(ctx), e => e.message === `console start lock is held by process ${process.pid}, which still runs; wait for its start or stop to finish`);
await assert.rejects(consoleStart(ctx, { detach: true, port: 'auto' }), /which still runs/);
assert.equal(readFileSync(lock, 'utf8'), live);
// A lock that names no holder (empty: a holder between its open and its write; or bad JSON) stays too.
for (const body of ['', '{"pid":', JSON.stringify({ pid: 0, startTime: '1' }), JSON.stringify({ pid: child.pid, startTime: 7 })]) {
writeFileSync(lock, body, { mode: 0o600 });
await assert.rejects(consoleStop(ctx), /console start lock exists and names no holder/);
assert.equal(readFileSync(lock, 'utf8'), body);
}
// f6c review P3-1: a lock its holder marked released (a clear put it back after the release) is
// cleared; a released marker with anything else in it names no holder and stays.
writeFileSync(lock, JSON.stringify({ released: true }), { mode: 0o600 });
warnings.length = 0;
assert.deepEqual(await consoleStop(ctx, { warn: s => warnings.push(s) }), { stopped: false });
assert.deepEqual(warnings, ['mosaic: cleared a console start lock its holder had released\n']);
assert.equal(existsSync(lock), false);
const odd = JSON.stringify({ released: true, pid: 1 });
writeFileSync(lock, odd, { mode: 0o600 });
await assert.rejects(consoleStop(ctx), /console start lock exists and names no holder/);
assert.equal(readFileSync(lock, 'utf8'), odd);
rmSync(lock);
});
@@ -136,3 +136,55 @@ test('T1 mosaic org definitions: writes go through the bus and its secret check,
await assert.rejects(orgCommand(['definitions', 'acme', 'remove', 'copy', '--if-rev', '1'], x), (e) => e.exitCode === 3 && /organization bus/.test(e.message));
assert.deepEqual(readFileSync(file), before);
});
// E2E6 fix 2: an unknown definition, an unknown organization, a bad id and a bad name each end in
// one usage or refusal line: no stack trace and no host path.
test('E2E6 mosaic org definitions: unknown names, an unknown org and a bad id give one line, no stack and no path', async (t) => {
const root = tmp(t);
const f = fixture(root, 'acme');
const { run } = await import('../src/cli.mjs');
const cases = [
[['acme', 'show', 'ghost'], 3, 'mosaic: definition-missing: definitions declares no ghost; list them with mosaic org definitions acme list'],
[['acme', 'diff', 'ghost'], 3, 'mosaic: definition-missing: definitions declares no ghost; list them with mosaic org definitions acme list'],
[['acme', 'show', 'Bad Name'], 3, 'mosaic: definition-missing: definitions declares no definition by that name; list them with mosaic org definitions acme list'],
[['nosuch', 'list'], 3, 'mosaic: unknown-organization: this instance has no organization nosuch; list them with mosaic org list'],
[['nosuch', 'show', 'x'], 3, 'mosaic: unknown-organization: this instance has no organization nosuch; list them with mosaic org list'],
];
for (const [args, exit, line] of cases) {
const x = io(f.env);
assert.equal(await run(['org', 'definitions', ...args], x, {}), exit, args.join(' '));
assert.equal(x.err.text, `${line}\n`, args.join(' '));
assert.ok(!x.err.text.includes(root) && !/\n\s+at /.test(x.err.text), args.join(' '));
}
for (const args of [['Bad/Id', 'list'], ['../x', 'show', 'y']]) {
const x = io(f.env);
assert.equal(await run(['org', 'definitions', ...args], x, {}), 4, args.join(' '));
assert.match(x.err.text, /^mosaic: invalid organization id: an id is 1 to 64 of a-z/);
assert.match(x.err.text, /\nmosaic org definitions templates \| definitions ID list/);
assert.ok(!x.err.text.includes(root) && !/\n\s+at /.test(x.err.text));
}
});
test('E2E6 definitionsFailure: a raw filesystem error is named by its operation and code, a message path is cut, an unknown error says only that it failed', async () => {
const { definitionsFailure } = await import('../src/org-definitions.mjs');
const fsError = (code, syscall) => Object.assign(new Error(`${code}: no such file, open '/home/someone/.config/x/acme.json'`), { code, syscall, path: '/home/someone/.config/x/acme.json' });
let e = definitionsFailure(fsError('EACCES', 'open'), 'acme');
assert.deepEqual([e.code, e.exitCode, e.message], ['organization-unreadable', 3, 'organization-unreadable: cannot open the file of organization acme (EACCES)']);
e = definitionsFailure(Object.assign(new Error("organization file /srv/x/acme.json is not valid"), { code: 'organization-invalid' }), 'acme');
assert.equal(e.message, 'organization-invalid: organization file <path> is not valid');
e = definitionsFailure(new TypeError('Cannot read properties of undefined'), 'acme');
assert.deepEqual([e.code, e.exitCode, e.message], ['definitions-failed', 1, 'definitions-failed: the definitions command failed']);
// f6c review P3-2: only the organization file missing means no organization.
e = definitionsFailure(fsError('ENOENT', 'open'), 'acme');
assert.deepEqual([e.code, e.message], ['unknown-organization', 'unknown-organization: this instance has no organization acme; list them with mosaic org list']);
const rolesGone = Object.assign(new Error("ENOENT: no such file or directory, scandir '/home/someone/roles'"), { code: 'ENOENT', syscall: 'scandir', path: '/home/someone/roles' });
e = definitionsFailure(rolesGone, 'templates');
assert.deepEqual([e.code, e.exitCode, e.message], ['definitions-unreadable', 3, 'definitions-unreadable: cannot scandir a file the definitions command reads (ENOENT)']);
e = definitionsFailure(rolesGone, 'acme');
assert.equal(e.code, 'organization-unreadable');
// f6c review P3-3: a path after ':' or inside backticks is cut.
e = definitionsFailure(Object.assign(new Error('organization file:/srv/x/acme.json is not valid'), { code: 'organization-invalid' }), 'acme');
assert.equal(e.message, 'organization-invalid: organization file:<path> is not valid');
e = definitionsFailure(Object.assign(new Error('bad role at `/srv/roles/x.json`'), { code: 'organization-invalid' }), 'acme');
assert.equal(e.message, 'organization-invalid: bad role at `<path>`');
});
+52
View File
@@ -97,3 +97,55 @@ test('SP4 an agent shell refuses every pack, board and workflow word, pack list
assert.deepEqual(s.calls, []);
assert.deepEqual(readFileSync(s.file), before);
});
// E2E6 fix 3: the real transport shape. humanTransport throws a CliError whose message and .code are
// the bus code alone (packages/cli/src/transport.mjs); pack, board and workflow refusals must still
// gain their hint, as template save's do, and a CliError with its own next line passes unchanged.
test('E2E6 pack, board and workflow refusals from a CliError-shaped transport print the hint', async (t) => {
const { CliError } = await import('../src/errors.mjs');
const { busExit, busNotRunning } = await import('../src/transport.mjs');
const root = tmp(t);
const f = fixture(root, 'acme');
const boot = bootConfig({ system: loadSystem({ env: f.env }), businessId: 'acme', env: f.env });
const b = await startBroker({ dataRoot: f.dataRoot, businesses: boot.businesses, organization: boot.organization });
t.after(() => b.close());
const human = b.broker.bindHuman({ business: 'acme', human: f.doc.human, via: 'cli', outsideAgent: true });
let down = false;
const deps = { system: { dataRoot: f.dataRoot }, transport: () => async (verb, args = {}) => {
if (down) throw busNotRunning('acme');
try { return structuredClone(await b.broker.request(human, { verb, args })); }
catch (e) { if (!(e instanceof BusError)) throw e; throw Object.assign(new CliError(e.code, busExit(e.code)), { code: e.code }); }
} };
const run = async (args) => { const x = io(f.env); await main(['org', ...args], x, deps); return JSON.parse(x.out.text); };
const hinted = (e) => typeof e.code === 'string' && e instanceof CliError && e.message.startsWith(`${e.code}: `) && e.message.length > e.code.length + 10;
await assert.rejects(run(['pack', 'preview', 'acme', 'no-such-pack']), (e) => e.code === 'starter-pack-not-found' && e.message === 'starter-pack-not-found: no installed, shipped or saved pack has that name');
const spec = join(root, 'board.json');
writeFileSync(spec, JSON.stringify({ columns: [{ state: 'todo', label: 'Backlog' }], layout: 'kanban' }));
await assert.rejects(run(['board', 'set', 'acme', spec]), (e) => hinted(e) && e.exitCode === busExit(e.code));
await assert.rejects(run(['workflow', 'remove', 'acme', 'ghost']), (e) => hinted(e) && e.exitCode === busExit(e.code));
// A stopped bus keeps its own message and next line.
down = true;
await assert.rejects(run(['pack', 'preview', 'acme', 'no-such-pack']), (e) => e.code === 'bus-not-running' && e.exitCode === 3
&& e.message === 'bus-not-running: the bus for acme is not running, so the request was not sent' && /mosaic bus start acme/.test(e.next) && /mosaic bus recover acme/.test(e.next));
});
// Ruling 2026-11-14: "If I choose a starter pack and apply it, that is a decision!" The owner's apply
// hires the proposals in the same act; pack hire runs the same loop on the packs entry and hires none twice.
test('PD mosaic org pack apply hires the proposals; pack hire on the same record hires nothing twice', async (t) => {
const s = await setup(t);
assert.ok(PACKS_USAGE.includes('pack hire ID PACK [--project P]'));
const preview = await s.run(['pack', 'preview', 'acme', 'coding']);
const applied = await s.run(['pack', 'apply', 'acme', 'coding', '--digest', preview.digest]);
assert.deepEqual(applied.hires.map((x) => [x.name, x.state]), [['pm-1', 'hired'], ['coder-1', 'hired'], ['reviewer-1', 'hired']]);
for (const x of applied.hires) assert.match(String(x.decision), /^[0-9a-f-]{36}$/);
const doc = s.doc();
for (const x of applied.hires) { assert.equal(doc.roles[x.name].hireDecision, x.decision); assert.ok(doc.launch.instances.includes(x.name), x.name); }
const again = await s.run(['pack', 'hire', 'acme', 'coding']);
assert.deepEqual(again.hires.map((x) => [x.name, x.state]), [['pm-1', 'exists'], ['coder-1', 'exists'], ['reviewer-1', 'exists']]);
assert.deepEqual(s.calls.at(-1), ['pack.hire', ['pack']]);
await assert.rejects(s.run(['pack', 'hire', 'acme', 'ghost-pack']), (e) => e.code === 'pack-not-applied' && /apply it first/.test(e.message));
await assert.rejects(s.run(['pack', 'hire', 'acme']), (e) => e.exitCode === 4 && e.message === PACKS_USAGE);
});
+6 -1
View File
@@ -37,8 +37,13 @@ test('organization host claim refuses a stale lock without removing it', t => {
const stale = { pid: 99999999, startTime: '0', business: 'alpha', startedAt: 'old' };
writeFileSync(hostLock(root), JSON.stringify(stale), { mode: 0o600 });
const mine = { pid: process.pid, startTime: startTimeOf(process.pid), business: 'alpha', startedAt: 'now' };
assert.throws(() => claimHostLock(root, mine, { refuseStale: true }), /stale.*lock/i);
// E2E6 fix 1: the message stays; the next line names the verb that clears the dead host.
assert.throws(() => claimHostLock(root, mine, { refuseStale: true }), e => e.message === 'stale bus host lock' && e.exitCode === 3
&& e.next === 'if the bus host died, clear it with mosaic bus recover alpha; recover refuses while the host still runs');
assert.deepEqual(JSON.parse(readFileSync(hostLock(root), 'utf8')), stale);
// A lock naming no valid organization id still names the verb, with a placeholder.
writeFileSync(hostLock(root), JSON.stringify({ ...stale, business: '../x\nsecret' }), { mode: 0o600 });
assert.throws(() => claimHostLock(root, mine, { refuseStale: true }), e => e.next === 'if the bus host died, clear it with mosaic bus recover <org>; recover refuses while the host still runs');
});
import { busStatus } from '../src/org-bus.mjs';
+4 -2
View File
@@ -40,7 +40,7 @@ test('SP8 mosaic org template save: --preview writes nothing, --digest writes th
const before = readFileSync(s.file);
const preview = await s.run(['template', 'save', 'acme', 'acme-shape', '--preview']);
assert.match(preview.digest, /^[0-9a-f]{64}$/);
assert.ok(Array.isArray(preview.freeText) && Array.isArray(preview.replacements));
assert.ok(Array.isArray(preview.freeText) && Array.isArray(preview.mentions) && !('replacements' in preview));
assert.ok(!existsSync(s.saved('acme-shape')), 'preview writes no file');
const out = await s.run(['template', 'save', 'acme', 'acme-shape', '--digest', preview.digest]);
@@ -49,7 +49,9 @@ test('SP8 mosaic org template save: --preview writes nothing, --digest writes th
assert.equal(lstatSync(s.saved('acme-shape')).mode & 0o777, 0o600);
assert.deepEqual(readFileSync(s.file), before, 'save writes nothing to the organization file');
await assert.rejects(s.run(['template', 'save', 'acme', 'acme-shape', '--digest', preview.digest]), (e) => e.code === 'invalid-request' && /already saved/.test(e.message));
await assert.rejects(s.run(['template', 'save', 'acme', 'acme-shape', '--digest', preview.digest]), (e) => e.code === 'template-exists' && e.exitCode === 2
&& e.message === 'template-exists: a template of this name is already saved for your account; nothing was written'
&& /under another name/.test(e.next) && /mosaic org template list acme/.test(e.next));
await assert.rejects(s.run(['template', 'save', 'acme', 'other', '--digest', preview.digest]), (e) => e.code === 'pack-plan-stale' && /preview again/.test(e.message));
const listed = await s.run(['template', 'list', 'acme']);
assert.deepEqual(listed.templates.map((x) => x.name), ['acme-shape']);
@@ -0,0 +1,93 @@
// #1873 ride-default, re-check 3 P1-1: `mosaic org update` that takes cliproxy off an organization
// records the removal in the instance's proxy receipts before it writes, as the Console's admin save
// does, so Ride all leaves the organization off.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { orgUpdate } from '../src/org.mjs';
import * as orgService from '../../organization/src/org-service.mjs';
import { createProxyAdmin } from '../../model-proxy/src/admin-control.mjs';
import { receiptFile } from '../../model-proxy/src/admin.mjs';
const owner = { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner' };
function scratch(t) {
const root = fs.mkdtempSync(join(tmpdir(), 'org-upd-'));
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
fs.mkdirSync(configDir, { mode: 0o700 }); fs.mkdirSync(dataRoot, { mode: 0o700 });
return { configDir, dataRoot, instance: 'test', principal: owner };
}
const receipts = dataRoot => { try { return fs.readFileSync(receiptFile(dataRoot), 'utf8').trim().split('\n').filter(Boolean).map(JSON.parse); } catch { return []; } };
const withProviders = (doc, list) => ({ ...doc, plugins: { ...(doc.plugins ?? {}), 'model-provider': list } });
async function cliproxyOrg(ctx, id) {
const doc = withProviders(await orgService.templateRender(id), ['cliproxy']);
await orgService.createOrg(ctx, id, doc);
return orgService.showOrg(ctx, id);
}
test('the reviewer probe: an organization taken off cliproxy by mosaic org update is skipped by Ride all as removed', async t => {
const ctx = scratch(t);
const shown = await cliproxyOrg(ctx, 'cli');
await orgUpdate(ctx, 'cli', withProviders(shown.doc, []), { ifRevision: shown.revision });
assert.deepEqual((await orgService.showOrg(ctx, 'cli')).doc.plugins['model-provider'], []);
assert.deepEqual(receipts(ctx.dataRoot).map(r => [r.op, r.org]), [['ride-removed', 'cli']]);
const writes = [];
const call = async verb => {
if (verb === 'plugins') return { revision: 'r', plugins: { 'model-provider': [] } };
if (verb === 'proxy.accounts') return { accounts: [] };
if (verb === 'plugins.set') { writes.push('cli'); return { revision: 'r2' }; }
throw new Error(`unexpected ${verb}`);
};
const proxy = createProxyAdmin({ dataRoot: ctx.dataRoot, configDir: ctx.configDir, unit: { unit: 'u', status: async () => ({}) }, buses: async () => ({ stopped: true, running: [] }), fetch: async () => ({}),
riders: async () => [{ id: 'cli', fixture: false, cliproxy: false, changes: '', call }] });
const r = await proxy.rideAll();
assert.deepEqual(r.added, []); assert.deepEqual(r.skipped, [{ id: 'cli', reason: 'removed' }]);
assert.deepEqual(writes, []);
});
test('mosaic org update records only a removal of cliproxy, and saves nothing when the record cannot be written', async t => {
const ctx = scratch(t);
const recorded = [];
const record = async id => { recorded.push(id); };
// Keeping cliproxy, or an organization that never had it, records nothing.
let shown = await cliproxyOrg(ctx, 'keep');
await orgUpdate(ctx, 'keep', { ...shown.doc }, { ifRevision: shown.revision, record });
const plain = await orgService.templateRender('plain');
await orgService.createOrg(ctx, 'plain', withProviders(plain, []));
shown = await orgService.showOrg(ctx, 'plain');
await orgUpdate(ctx, 'plain', { ...shown.doc }, { ifRevision: shown.revision, record });
assert.deepEqual(recorded, []);
// A stale revision records nothing and is refused by the service.
shown = await cliproxyOrg(ctx, 'stale');
await assert.rejects(orgUpdate(ctx, 'stale', withProviders(shown.doc, []), { ifRevision: shown.revision + 1, record }), { code: 'revision-conflict' });
assert.deepEqual(recorded, []);
// A record that fails refuses the update: the organization keeps cliproxy, at the same revision.
await assert.rejects(orgUpdate(ctx, 'stale', withProviders(shown.doc, []), { ifRevision: shown.revision, record: async () => { throw Object.assign(new Error('disk full at /x/proxy-admin.jsonl'), { code: 'ENOSPC' }); } }),
err => err.exitCode === 3 && err.message === 'the removal of the model proxy could not be recorded, so nothing was saved');
const after = await orgService.showOrg(ctx, 'stale');
assert.deepEqual(after.doc.plugins['model-provider'], ['cliproxy']); assert.equal(after.revision, shown.revision);
// The removal itself records once, before the write.
await orgUpdate(ctx, 'stale', withProviders(shown.doc, []), { ifRevision: shown.revision, record: async id => { recorded.push(id); assert.deepEqual((await orgService.showOrg(ctx, 'stale')).doc.plugins['model-provider'], ['cliproxy'], 'recorded before the write'); } });
assert.deepEqual(recorded, ['stale']);
});
test('the mosaic org update command records the removal in the instance\'s own proxy receipts', async t => {
const { spawnSync } = await import('node:child_process');
const { resolve } = await import('node:path');
const repo = resolve(import.meta.dirname, '../../..');
const home = fs.mkdtempSync(join(tmpdir(), 'org-upd-cli-'));
t.after(() => fs.rmSync(home, { recursive: true, force: true }));
const env = { ...process.env, HOME: home, MOSAIC_CONFIG: join(home, '.config/mosaic-orgupd/config.json') };
const run = (cmd, ...args) => { const r = spawnSync(join(repo, cmd), args, { cwd: repo, env, encoding: 'utf8' }); assert.equal(r.status, 0, r.stderr); return r.stdout; };
run('scripts/bootstrap.sh', '--instance', 'orgupd');
const on = join(home, 'on.json'), off = join(home, 'off.json');
const doc = withProviders(await orgService.templateRender('cliw'), ['cliproxy']);
fs.writeFileSync(on, JSON.stringify(doc)); fs.writeFileSync(off, JSON.stringify(withProviders(doc, [])));
run('scripts/mosaic', 'org', 'create', 'cliw', '--from', on);
const { revision } = JSON.parse(run('scripts/mosaic', 'org', 'show', 'cliw', '--json'));
run('scripts/mosaic', 'org', 'update', 'cliw', '--from', off, '--if-revision', String(revision));
assert.deepEqual(JSON.parse(run('scripts/mosaic', 'org', 'show', 'cliw', '--json')).doc.plugins['model-provider'], []);
assert.deepEqual(receipts(join(home, '.mosaic-orgupd')).map(r => [r.op, r.org]), [['ride-removed', 'cliw']]);
});
+29 -2
View File
@@ -1,8 +1,8 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { readFileSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { busExit, humanTransport, refuseInsideAgent } from "../src/transport.mjs";
import { busExit, humanTransport, refuseInsideAgent, HUMAN_CLI } from "../src/transport.mjs";
import { fakeCli, humanEnv, tmp } from "./helpers.mjs";
// The fake records argv and stdin, then answers per verb. The real
@@ -15,6 +15,8 @@ const { verb } = JSON.parse(input);
if (verb === "inbox") process.stdout.write(JSON.stringify([{ id: "d1" }]) + "\\n");
else if (verb === "garbage") process.stdout.write("not json");
else if (verb === "hang") setTimeout(() => {}, 60000);
else if (verb === "not-sent") { process.stderr.write("outcome-unknown\\n"); process.exit(5); }
else if (verb === "not-sent-other") { process.stderr.write("human-required\\n"); process.exit(5); }
else { process.stderr.write("some noise\\n" + verb + "\\n"); process.exit(2); }
`;
@@ -50,3 +52,28 @@ test("busExit and refuseInsideAgent", () => {
assert.doesNotThrow(() => refuseInsideAgent(humanEnv()));
assert.throws(() => refuseInsideAgent({ PI_AGENT_DIR: "/x" }), (e) => e.exitCode === 3 && /PI_AGENT_DIR/.test(e.message));
});
// E2E6 fix 6: the shim exits 5 when its connect failed before the request was written. That is a stopped
// bus: mosaic says so with the start and recover line. outcome-unknown stays for a request that left.
test("E2E6 exit 5 with outcome-unknown is bus-not-running; exit 2 with outcome-unknown is unchanged", async (t) => {
const s = setup(t);
await assert.rejects(s.call("not-sent"), (e) => e.code === "bus-not-running" && e.exitCode === 3
&& e.message === "bus-not-running: the bus for acme is not running, so the request was not sent"
&& e.next === "start it with mosaic bus start acme, or clear a host that died with mosaic bus recover acme");
await assert.rejects(s.call("outcome-unknown"), (e) => e.code === "outcome-unknown" && e.exitCode === 1 && e.message === "outcome-unknown" && e.next === undefined);
// Exit 5 says only that nothing was sent; any other code it carries keeps its own meaning.
await assert.rejects(s.call("not-sent-other"), (e) => e.code === "human-required" && e.exitCode === 3);
assert.equal(busExit("bus-not-running"), 3);
});
// The real shim, with no bus behind the path: nothing reaches a broker, so no proof runs. A missing socket
// and a path that is not a listening socket are both a bus that is not running.
test("E2E6 the real human shim against a missing socket or a plain file says the bus is not running", async (t) => {
const root = tmp(t);
const plain = join(root, "plain.sock");
writeFileSync(plain, "");
for (const socket of [join(root, "missing.sock"), plain]) {
const call = humanTransport({ socket, business: "acme", env: humanEnv(), cli: HUMAN_CLI, timeoutMs: 20000 });
await assert.rejects(call("inbox"), (e) => e.code === "bus-not-running" && e.exitCode === 3, socket);
}
});
+695
View File
@@ -0,0 +1,695 @@
// #1873 triage-key: `mosaic triage key issue|rotate|retire|status`, Triage's own model proxy key.
// A stand-in management server on loopback and a temporary config directory only; nothing here
// reads a real config, proxy or secret. Every stdout, stderr, receipt and file the verbs leave is
// scanned for every key the stand-in ever saw, at the end of each test and once more at the end.
import { test } from "node:test";
import assert from "node:assert/strict";
import { spawn, spawnSync } from "node:child_process";
import fs from "node:fs";
import http from "node:http";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createHash, randomBytes } from "node:crypto";
import { run } from "../src/cli.mjs";
import { AGENT_MARKERS } from "../src/transport.mjs";
import { DEFAULT_ROTATE_GRACE_MINUTES, keyPaths, retireAtFor, rotateByFor } from "../src/triage-key.mjs";
import { ModelKeys } from "../../bus/src/model-keys.mjs";
import { ManagementClient } from "../../model-proxy/src/client.mjs";
import { startBroker } from "../../bus/src/runtime.mjs";
import { busOrganization } from "../../bus/src/organization-context.mjs";
import { Registry } from "../../seat/src/session.mjs";
import { loadBusiness } from "../../organization/src/organization-config.mjs";
import { resolveInstance } from "../../organization/src/resolve.mjs";
import { businessDoc, rolesCopy, systemFor, writeJson } from "../../organization/tests/helpers.mjs";
import { humanEnv, io } from "./helpers.mjs";
const REPO = new URL("../../../", import.meta.url).pathname;
const NOW = Date.parse("2026-11-18T12:00:00.000Z");
const MIN = 60_000, HOUR = 60 * MIN, DAY = 24 * HOUR;
const MANAGE = "fx1873-manage";
const KEY_PATH = "/v8/management/config/access/api-keys";
const sha = (s) => createHash("sha256").update(s).digest("hex");
const tag = (dir) => sha(dir).slice(0, 12);
const id = (key) => sha(key).slice(0, 12);
const b64 = () => randomBytes(32).toString("base64url");
const iso = (ms) => new Date(ms).toISOString();
// Every output any verb produced in this file, and every Triage key the stand-in ever held.
const OUTPUTS = [];
const SEEN = new Set();
const VERBS = ["issue", "rotate", "retire", "status"];
function leaks(text, keys = SEEN) {
for (const key of keys) {
const secret = key.slice(-43);
if (text.includes(key) || text.includes(secret)) return true;
for (let i = 0; i + 8 <= secret.length; i++) if (text.includes(secret.slice(i, i + 8))) return true;
}
return false;
}
function walk(dir, skip, out = []) {
for (const name of fs.readdirSync(dir)) {
const p = join(dir, name), st = fs.lstatSync(p);
if (st.isDirectory()) walk(p, skip, out);
else if (st.isFile() && !skip.includes(p)) out.push(p);
}
return out;
}
async function fixture(t, { sentinel = true } = {}) {
const root = fs.realpathSync(fs.mkdtempSync(join(tmpdir(), "tk-")));
const configDir = join(root, "config");
fs.mkdirSync(join(configDir, "secrets"), { recursive: true, mode: 0o700 });
fs.chmodSync(configDir, 0o700); fs.chmodSync(join(configDir, "secrets"), 0o700);
fs.writeFileSync(join(configDir, "secrets", "proxy-management.key"), MANAGE, { mode: 0o600 });
fs.mkdirSync(join(root, "proxy"), { mode: 0o700 });
const prefix = `mst-${tag(configDir)}-triage-`;
const state = {
keys: [...(sentinel ? [`msk-${tag(configDir)}-sentinel-${b64()}`] : []), "foreign-client-key", `mso-${tag(configDir)}-demo-key-${b64()}`],
gets: 0, puts: [], ignorePut: false, dropSentinelOnPut: false, onGet: null,
};
const server = http.createServer(async (req, res) => {
if (req.url !== KEY_PATH) {
const key = req.headers.authorization?.slice(7);
res.writeHead(state.keys.includes(key) ? 200 : 401); res.end("{}"); return;
}
if (req.headers.authorization !== `Bearer ${MANAGE}`) { res.writeHead(401); res.end("{}"); return; }
if (req.method === "GET") { state.gets++; const body = JSON.stringify(state.keys); state.onGet?.(state.gets); res.end(body); return; }
const chunks = []; for await (const c of req) chunks.push(c);
const next = JSON.parse(Buffer.concat(chunks));
for (const k of next) if (/^mst-.*-[A-Za-z0-9_-]{43}$/.test(k)) SEEN.add(k);
state.puts.push(next);
if (state.dropSentinelOnPut) state.keys = next.filter((k) => !k.startsWith("msk-") || !k.includes("-sentinel-"));
else if (!state.ignorePut) state.keys = next;
res.end('{"status":"ok"}');
});
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
const port = server.address().port;
const closers = [];
t.after(async () => {
for (const close of closers) await close();
server.closeAllConnections(); await new Promise((resolve) => server.close(resolve));
fs.rmSync(root, { recursive: true, force: true });
});
const f = {
root, configDir, prefix, state, server, port, closers, now: NOW,
system: { dataRoot: root, proxy: { port, binary: "/fixture-unused" } },
file: keyPaths(configDir).file, dir: keyPaths(configDir).dir,
env: (extra = {}) => humanEnv({ MOSAIC_CONFIG: join(configDir, "config.json"), ...extra }),
async cli(argv, { env, deps = {}, system = f.system } = {}) {
const s = io(env ?? f.env());
const code = await run(argv, s, { system, now: () => new Date(f.now), ...deps });
const out = { code, stdout: s.out.text, stderr: s.err.text };
OUTPUTS.push(out.stdout, out.stderr);
return out;
},
// The same verb in a child process that SIGKILLs itself at `stage`.
crash(argv, stage) {
const script = `
import { run } from ${JSON.stringify(new URL("../src/cli.mjs", import.meta.url).href)};
import { io } from ${JSON.stringify(new URL("./helpers.mjs", import.meta.url).href)};
const p = JSON.parse(process.env.TK_CRASH);
const s = io(process.env);
const code = await run(p.argv, s, { system: p.system, now: () => new Date(p.now),
triageKeyHook: (stage) => { if (stage === p.stage) process.kill(process.pid, "SIGKILL"); } });
process.stdout.write(s.out.text); process.stderr.write(s.err.text); process.exitCode = code;`;
const env = f.env({ TK_CRASH: JSON.stringify({ argv, stage, system: f.system, now: f.now }) });
return new Promise((resolve) => {
const child = spawn(process.execPath, ["--input-type=module", "-e", script], { env, stdio: ["ignore", "pipe", "pipe"] });
let stdout = "", stderr = "";
child.stdout.on("data", (d) => { stdout += d; });
child.stderr.on("data", (d) => { stderr += d; });
child.on("exit", (code, signal) => { OUTPUTS.push(stdout, stderr); resolve({ code, signal, stdout, stderr }); });
});
},
record: () => JSON.parse(fs.readFileSync(f.file, "utf8")),
triageKeys: () => state.keys.filter((k) => k.startsWith(prefix)),
receipts: () => {
const file = join(root, "proxy", "mosaic-keys.receipts.jsonl");
return fs.existsSync(file) ? fs.readFileSync(file, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)) : [];
},
fenced: () => fs.existsSync(join(root, "proxy", "mosaic-keys.uncertain")),
// No file under the fixture but the key file itself holds a key; neither does any output.
scan(alsoKeyFiles = []) {
for (const k of state.keys) if (/^mst-.*-[A-Za-z0-9_-]{43}$/.test(k)) SEEN.add(k);
for (const p of walk(root, [f.file, join(configDir, "secrets", "proxy-management.key"), ...alsoKeyFiles])) {
assert.equal(leaks(fs.readFileSync(p, "latin1")), false, `a key is in ${p}`);
}
for (const text of OUTPUTS) assert.equal(leaks(text), false, "a key is in an output");
},
};
return f;
}
const ok = (r) => assert.equal(r.code, 0, r.stderr);
const refusal = (r, code, words) => {
assert.equal(r.code, 3, r.stderr);
assert.equal(r.stdout, "");
assert.match(r.stderr, new RegExp(`^mosaic: ${code}: ${words ?? ""}`));
};
test("issue adds one key under the lock, writes the 0600 file, and records ids only", async (t) => {
const f = await fixture(t);
const before = [...f.state.keys];
const r = await f.cli(["triage", "key", "issue"]);
ok(r);
const rec = f.record();
assert.deepEqual(Object.keys(rec), ["version", "key", "keyId", "issuedAt", "rotateBy", "retiring"]);
assert.match(rec.key, new RegExp(`^${f.prefix}[A-Za-z0-9_-]{43}$`));
assert.equal(rec.keyId, id(rec.key));
assert.equal(rec.issuedAt, iso(NOW));
assert.equal(rec.rotateBy, "2026-12-18");
assert.deepEqual(rec.retiring, []);
assert.equal(r.stdout, `triage key issued: ${rec.keyId}, rotate by 2026-12-18\nfile: ${f.file}\n`);
assert.deepEqual(f.state.keys, [...before, rec.key]);
assert.equal(f.state.puts.length, 1);
const file = fs.lstatSync(f.file), dir = fs.lstatSync(f.dir);
assert.equal(file.mode & 0o777, 0o600); assert.equal(dir.mode & 0o777, 0o700);
assert.equal(file.uid, process.getuid()); assert.equal(dir.uid, process.getuid());
assert.deepEqual(f.receipts(), [{ op: "triage.key.issue", time: iso(NOW), addedKeyIds: [rec.keyId], removedKeyIds: [] }]);
assert.equal(f.fenced(), false);
assert.equal(fs.readFileSync(join(f.root, "proxy", "keys.generation"), "utf8"), "1\n");
// A second issue refuses and changes nothing; rotate is the verb for that.
const again = await f.cli(["triage", "key", "issue"]);
refusal(again, "triage-key-issued", "a Triage key is already issued; use mosaic triage key rotate\n$");
assert.equal(f.state.puts.length, 1);
assert.deepEqual(f.record(), rec);
f.scan();
});
test("status reads the file and the list and writes nothing", async (t) => {
const f = await fixture(t);
const none = await f.cli(["triage", "key", "status"]);
ok(none);
assert.equal(none.stdout, `triage key: not issued\nfile: ${f.file}\nproxy: read\nnext: mosaic triage key issue\n`);
ok(await f.cli(["triage", "key", "issue"]));
const rec = f.record(), puts = f.state.puts.length, receipts = f.receipts().length;
f.now = NOW + 3 * DAY + 4 * HOUR + 5 * MIN;
const shown = await f.cli(["triage", "key", "status"]);
ok(shown);
assert.equal(shown.stdout, [
"triage key: issued", `file: ${f.file}`, `key id: ${rec.keyId}`, `issued: ${iso(NOW)} (age 3d 4h 5m)`,
"rotate by: 2026-12-18", "proxy: holds the key", "next: nothing", "",
].join("\n"));
f.now = Date.parse("2026-12-18T00:00:00.000Z");
assert.match((await f.cli(["triage", "key", "status"])).stdout, /rotate by: 2026-12-18 \(due\)\n[^]*next: mosaic triage key rotate\n$/);
f.now = NOW + HOUR;
f.state.keys = f.state.keys.filter((k) => k !== rec.key);
assert.match((await f.cli(["triage", "key", "status"])).stdout, /proxy: does not hold the key\nnext: mosaic triage key rotate\n$/);
assert.equal(f.state.puts.length, puts);
assert.equal(f.receipts().length, receipts);
assert.equal(fs.readdirSync(join(f.root, "proxy")).includes("mosaic-keys.lock"), false);
f.scan();
});
test("rotate adds a new key and keeps the old one for the bus grace; retire removes it once due", async (t) => {
const f = await fixture(t);
refusal(await f.cli(["triage", "key", "rotate"]), "triage-key-not-issued", "no Triage key is issued; use mosaic triage key issue\n$");
assert.equal(f.state.puts.length, 0);
ok(await f.cli(["triage", "key", "issue"]));
const first = f.record();
f.now = NOW + HOUR;
const r = await f.cli(["triage", "key", "rotate"]);
ok(r);
const second = f.record();
const retireAt = iso(NOW + HOUR + 120 * MIN);
assert.notEqual(second.key, first.key);
assert.equal(second.issuedAt, iso(NOW + HOUR));
assert.deepEqual(second.retiring, [{ key: first.key, keyId: first.keyId, issuedAt: first.issuedAt, retireAt }]);
assert.equal(r.stdout, `triage key rotated: ${second.keyId}, rotate by 2026-12-18\nold key ${first.keyId} stays live until mosaic triage key retire runs at or after ${retireAt}\n`);
assert.deepEqual(f.triageKeys(), [first.key, second.key]);
f.now = NOW + HOUR + 119 * MIN;
const early = await f.cli(["triage", "key", "retire"]);
ok(early);
assert.equal(early.stdout, "triage key retire: nothing to remove\n");
assert.equal(f.state.puts.length, 2);
assert.match((await f.cli(["triage", "key", "status"])).stdout, new RegExp(`retiring: ${first.keyId}, live until a retire after ${retireAt}\\n[^]*next: nothing\\n$`));
f.now = NOW + HOUR + 120 * MIN;
assert.match((await f.cli(["triage", "key", "status"])).stdout, new RegExp(`retiring: ${first.keyId}, live until a retire after ${retireAt} \\(due\\)\\n[^]*next: mosaic triage key retire\\n$`));
const done = await f.cli(["triage", "key", "retire"]);
ok(done);
assert.equal(done.stdout, `triage key retire: removed ${first.keyId}\n`);
assert.deepEqual(f.triageKeys(), [second.key]);
assert.deepEqual(f.record(), { ...second, retiring: [] });
assert.deepEqual(f.receipts().map((e) => e.op), ["triage.key.issue", "triage.key.rotate", "triage.key.retire"]);
assert.deepEqual(f.receipts()[2].removedKeyIds, [first.keyId]);
f.scan();
});
test("rotate takes the grace from proxy.json, where the bus reads it, and drops an old key the proxy lost", async (t) => {
const f = await fixture(t);
f.system = { ...f.system, proxy: { ...f.system.proxy, rotateGraceMinutes: 30 } };
ok(await f.cli(["triage", "key", "issue"]));
const first = f.record();
ok(await f.cli(["triage", "key", "rotate"]));
const second = f.record();
assert.equal(second.retiring[0].retireAt, iso(NOW + 30 * MIN));
// The proxy lost the current key: rotate drops it at once, as the bus does for an agent key.
f.state.keys = f.state.keys.filter((k) => k !== second.key);
const r = await f.cli(["triage", "key", "rotate"]);
ok(r);
assert.match(r.stdout, new RegExp(`old key ${second.keyId} was not in the proxy list; nothing to retire\\n$`));
assert.deepEqual(f.record().retiring.map((e) => e.keyId), [first.keyId]);
// A retiring key past its time, or no longer in the list, leaves on the next rotate.
f.now = NOW + 31 * MIN;
ok(await f.cli(["triage", "key", "rotate"]));
const last = f.record();
assert.deepEqual(last.retiring.map((e) => e.keyId), [id(f.triageKeys()[0])]);
assert.equal(f.triageKeys().includes(first.key), false);
assert.equal(f.triageKeys().length, 2);
f.scan();
});
test("lifetime and grace match the bus's own ModelKeys for the same clock and proxy settings", async (t) => {
const runtime = fs.readFileSync(join(REPO, "packages/bus/src/runtime.mjs"), "utf8");
const literal = runtime.match(/rotateGraceMinutes: proxy\.rotateGraceMinutes \?\? (\d+)/);
assert.ok(literal, "the bus no longer reads rotateGraceMinutes as this test expects");
assert.equal(Number(literal[1]), DEFAULT_ROTATE_GRACE_MINUTES);
for (const grace of [undefined, 45]) {
const f = await fixture(t);
if (grace !== undefined) f.system = { ...f.system, proxy: { ...f.system.proxy, rotateGraceMinutes: grace } };
ok(await f.cli(["triage", "key", "issue"]));
f.now = NOW + 3 * HOUR;
ok(await f.cli(["triage", "key", "rotate"]));
const ours = f.record();
// The bus, driven the way runtime.mjs drives it, on its own in-memory list.
let keys = [`msk-${tag(f.configDir)}-sentinel-${b64()}`], record = null, now = NOW;
const credentials = { registerModel() {}, modelRecord: () => record, writeModel: (_, r) => { record = r; }, status: () => [] };
const client = { getKeys: async () => [...keys], putKeys: async (k) => { keys = [...k]; return { ok: true }; } };
const bus = new ModelKeys({ credentials, client, configDir: f.configDir, baseUrl: "http://127.0.0.1:1", now: () => now,
...(grace === undefined ? {} : { rotateGraceMinutes: f.system.proxy.rotateGraceMinutes ?? Number(literal[1]) }) });
await bus.reconcile();
await bus.ensure("demo/x");
assert.equal(record.rotateBy, rotateByFor(NOW));
now = NOW + 3 * HOUR;
await bus.rotate("demo/x");
assert.equal(ours.rotateBy, record.rotateBy);
assert.equal(ours.retiring[0].retireAt, record.retiring[0].retireAt);
assert.equal(ours.retiring[0].retireAt, retireAtFor(now, f.system.proxy));
f.scan();
}
});
test("an agent caller is refused before anything is read, for every key verb", async (t) => {
const f = await fixture(t);
for (const marker of AGENT_MARKERS) {
for (const verb of VERBS) {
const r = await f.cli(["triage", "key", verb], { env: { ...f.env(), [marker]: "1" } });
assert.equal(r.code, 3, marker);
assert.equal(r.stderr, `mosaic: refused: this runs only from a human shell, outside any agent run (found ${marker} in the environment)\n`);
}
const saved = process.env[marker];
process.env[marker] = "1";
try {
for (const verb of VERBS) {
const r = await f.cli(["triage", "key", verb]);
assert.equal(r.code, 3, marker);
assert.match(r.stderr, new RegExp(`found ${marker} in the environment`));
}
} finally { if (saved === undefined) delete process.env[marker]; else process.env[marker] = saved; }
}
assert.equal(f.state.gets, 0);
assert.equal(f.state.puts.length, 0);
assert.equal(fs.existsSync(f.dir), false);
assert.deepEqual(fs.readdirSync(join(f.root, "proxy")), []);
});
test("usage: unknown key verbs, options and arguments exit 4 and echo no value", async (t) => {
const f = await fixture(t);
for (const argv of [["triage", "key"], ["triage", "key", "nope"], ["triage", "key", "issue", "extra"], ["triage", "key", "status", "--json"]]) {
const r = await f.cli(argv);
assert.equal(r.code, 4, argv.join(" "));
assert.equal(r.stdout, "");
assert.match(r.stderr, /\nusage: mosaic triage route show [^\n]*\| key issue \| rotate \| retire \| status\n$/);
}
const r = await f.cli(["triage", "key", "rotate", "--key", "secret-value"]);
assert.equal(r.code, 4);
assert.match(r.stderr, /^mosaic: unknown option\n/);
assert.doesNotMatch(r.stderr, /secret-value/);
assert.equal(f.state.gets, 0);
});
test("an unsafe key store refuses every verb before any proxy write", async (t) => {
const uid = process.getuid();
const cases = [
["file mode", (f) => fs.chmodSync(f.file, 0o644), {}, "the key file mode is not 0600"],
["file owner", () => {}, { triageKeyFileUid: uid + 1 }, "the key file is not owned by this user"],
["file link", (f) => { fs.renameSync(f.file, join(f.dir, "real")); fs.symlinkSync(join(f.dir, "real"), f.file); }, {}, "the key file is a link"],
["file is a directory", (f) => { fs.rmSync(f.file); fs.mkdirSync(f.file, { mode: 0o700 }); }, {}, "the key file is not a regular file"],
["file is a FIFO", (f) => { fs.rmSync(f.file); assert.equal(spawnSync("mkfifo", ["-m", "600", f.file]).status, 0); }, {}, "the key file is not a regular file"],
["hard link", (f) => fs.linkSync(f.file, join(f.dir, "second")), {}, "the key file has more than one link"],
["not JSON", (f) => fs.writeFileSync(f.file, "{"), {}, "the key file is not JSON"],
["extra field", (f) => fs.writeFileSync(f.file, JSON.stringify({ ...f.record(), extra: 1 })), {}, "the key file does not match the key shape"],
["another instance's key", (f) => { const r = f.record(); const key = `mst-${tag("/elsewhere")}-triage-${b64()}`; fs.writeFileSync(f.file, JSON.stringify({ ...r, key, keyId: id(key) })); }, {}, "the key file does not match the key shape"],
["wrong key id", (f) => fs.writeFileSync(f.file, JSON.stringify({ ...f.record(), keyId: "000000000000" })), {}, "the key file does not match the key shape"],
["too large", (f) => fs.writeFileSync(f.file, " ".repeat(64 * 1024 + 1)), {}, "the key file is too large"],
["triage directory mode", (f) => fs.chmodSync(f.dir, 0o755), {}, "the triage secrets directory mode is not 0700"],
["triage directory link", (f) => { fs.renameSync(f.dir, join(f.configDir, "secrets", "moved")); fs.symlinkSync(join(f.configDir, "secrets", "moved"), f.dir); }, {}, "the triage secrets directory is a link"],
["triage directory is a file", (f) => { fs.rmSync(f.dir, { recursive: true }); fs.writeFileSync(f.dir, "", { mode: 0o600 }); }, {}, "the triage secrets directory is not a directory"],
["secrets mode", (f) => fs.chmodSync(join(f.configDir, "secrets"), 0o750), {}, "the secrets directory mode is not 0700"],
["owner", () => {}, { triageKeyUid: uid + 1 }, "the secrets directory is not owned by this user"],
];
for (const [name, spoil, deps, words] of cases) {
const f = await fixture(t);
ok(await f.cli(["triage", "key", "issue"]));
spoil(f);
const keys = [...f.state.keys], puts = f.state.puts.length;
for (const verb of VERBS) {
const r = await f.cli(["triage", "key", verb], { deps });
refusal(r, "triage-key-unreadable", `the Triage key store is unreadable: ${words.replace(/[.()]/g, "\\$&")}\n$`);
assert.equal(f.state.puts.length, puts, `${name}: ${verb}`);
}
assert.deepEqual(f.state.keys, keys);
// The spoils above move or link the key file itself; those copies are the key file.
f.scan([join(f.dir, "real"), join(f.dir, "second"), join(f.configDir, "secrets", "moved", "model")]);
}
// No secrets directory at all: status says not issued; issue refuses before the proxy changes.
const f = await fixture(t);
fs.rmSync(join(f.configDir, "secrets"), { recursive: true });
fs.mkdirSync(join(f.configDir, "secrets"), { mode: 0o700 });
fs.writeFileSync(join(f.configDir, "secrets", "proxy-management.key"), MANAGE, { mode: 0o600 });
fs.chmodSync(join(f.configDir, "secrets"), 0o755);
refusal(await f.cli(["triage", "key", "issue"]), "triage-key-unreadable", "the Triage key store is unreadable: the secrets directory mode is not 0700\n$");
assert.equal(f.state.puts.length, 0);
});
test("the instance proxy lock, the fence, the sentinel and the proxy itself each refuse plainly", async (t) => {
// Lock held by a live process: busy after the lock's wait, and nothing changes.
const f = await fixture(t);
const lockFile = join(f.root, "proxy", "mosaic-keys.lock");
ok(await f.cli(["triage", "key", "status"]));
fs.writeFileSync(lockFile, `${JSON.stringify({ pid: process.pid, token: "a".repeat(32) })}\n`, { mode: 0o600 });
const busy = await f.cli(["triage", "key", "issue"]);
refusal(busy, "proxy-lock-busy", "another proxy writer holds the instance proxy lock; try again when it ends, and if no writer is running, see mosaic proxy fence status\n$");
assert.equal(f.state.gets, 1);
// A lock left by a process that is gone is reaped, and the verb goes ahead.
const dead = spawnSync(process.execPath, ["-e", ""]).pid;
fs.writeFileSync(lockFile, `${JSON.stringify({ pid: dead, token: "b".repeat(32) })}\n`, { mode: 0o600 });
ok(await f.cli(["triage", "key", "issue"]));
assert.equal(fs.existsSync(lockFile), false);
assert.equal(f.triageKeys().length, 1);
fs.rmSync(f.file);
f.state.keys = f.state.keys.filter((k) => !k.startsWith(f.prefix));
// A set fence: every write refuses, status names it and the way out.
const putsBefore = f.state.puts.length;
fs.writeFileSync(join(f.root, "proxy", "mosaic-keys.uncertain"), "{}\n", { mode: 0o600 });
for (const verb of ["issue", "rotate", "retire"]) refusal(await f.cli(["triage", "key", verb]), "proxy-uncertain");
assert.match((await f.cli(["triage", "key", "status"])).stdout, /proxy fence: set, an earlier proxy write has an uncertain outcome\nnext: restart the proxy, then mosaic proxy fence clear --proxy-restarted\n$/);
assert.equal(f.state.puts.length, putsBefore);
// No sentinel for this instance (another instance's does not count).
const g = await fixture(t, { sentinel: false });
g.state.keys.push(`msk-${tag("/elsewhere")}-sentinel-${b64()}`);
refusal(await g.cli(["triage", "key", "issue"]), "triage-key-proxy-open");
assert.match((await g.cli(["triage", "key", "status"])).stdout, /proxy: its key list has no sentinel for this instance\nnext: check the proxy with mosaic proxy status\n$/);
assert.equal(g.state.puts.length, 0);
// No proxy set up, no management key, proxy down.
const h = await fixture(t);
const bare = { dataRoot: h.root };
refusal(await h.cli(["triage", "key", "issue"], { system: bare }), "triage-key-no-proxy");
assert.equal((await h.cli(["triage", "key", "status"], { system: bare })).stdout,
`triage key: not issued\nfile: ${h.file}\nproxy: not set up for this instance (no proxy.json)\nnext: set up the model proxy first (mosaic proxy init)\n`);
fs.chmodSync(join(h.configDir, "secrets", "proxy-management.key"), 0o644);
refusal(await h.cli(["triage", "key", "issue"]), "proxy-management-key-invalid");
fs.chmodSync(join(h.configDir, "secrets", "proxy-management.key"), 0o600);
h.server.closeAllConnections(); await new Promise((resolve) => h.server.close(resolve));
h.server.close = (cb) => cb();
refusal(await h.cli(["triage", "key", "issue"]), "proxy-client-down");
assert.match((await h.cli(["triage", "key", "status"])).stdout, /proxy: not read \(proxy-client-down\)\n/);
assert.equal(fs.existsSync(h.file), false);
f.scan(); g.scan(); h.scan();
});
test("a write the proxy does not confirm keeps the fence; a list that moves mid-verb is not overwritten", async (t) => {
const f = await fixture(t);
f.state.ignorePut = true;
refusal(await f.cli(["triage", "key", "issue"]), "triage-key-unconfirmed");
assert.equal(f.fenced(), true);
assert.equal(fs.existsSync(f.file), false);
// The store's directory was made and checked before the proxy changed, not after.
assert.equal(fs.lstatSync(f.dir).mode & 0o777, 0o700);
assert.deepEqual(f.receipts(), []);
// A PUT the proxy takes but whose read-back has lost this instance's sentinel is not confirmed.
const s = await fixture(t);
s.state.dropSentinelOnPut = true;
refusal(await s.cli(["triage", "key", "issue"]), "triage-key-unconfirmed");
assert.equal(s.fenced(), true);
assert.equal(fs.existsSync(s.file), false);
s.scan();
const g = await fixture(t);
g.state.onGet = (n) => { if (n === 1) g.state.keys = [...g.state.keys, "late-foreign-key"]; };
refusal(await g.cli(["triage", "key", "issue"]), "triage-key-raced");
assert.equal(g.state.puts.length, 0);
assert.equal(g.fenced(), false);
f.scan(); g.scan();
});
test("keys outside the Triage namespace are never touched; Triage keys the file does not hold are removed", async (t) => {
const f = await fixture(t);
const agent = `msk-${tag(f.configDir)}-${b64()}`, other = `mst-${tag("/elsewhere")}-triage-${b64()}`;
const orphan = `${f.prefix}${b64()}`, odd = `${f.prefix}short`;
f.state.keys.push(agent, other, orphan, odd);
const foreign = f.state.keys.filter((k) => k !== orphan && k !== odd);
const r = await f.cli(["triage", "key", "issue"]);
ok(r);
// A malformed name under the Triage prefix is still Triage's, as the bus treats its own prefix.
assert.match(r.stdout, new RegExp(`removed keys this file did not hold: ${id(orphan)}, ${id(odd)}\\n$`));
for (const verb of ["rotate", "retire"]) { f.now += 3 * HOUR; ok(await f.cli(["triage", "key", verb])); }
for (const k of foreign) assert.ok(f.state.keys.includes(k), "a key outside the namespace left the list");
assert.equal(f.state.keys.includes(orphan), false);
assert.equal(f.state.keys.includes(odd), false);
assert.deepEqual(f.triageKeys(), [f.record().key]);
f.scan();
});
test("crash after the PUT, before the read-back: the fence holds; status says so; clear, then issue recovers", async (t) => {
const f = await fixture(t);
const crashed = await f.crash(["triage", "key", "issue"], "put");
assert.equal(crashed.signal, "SIGKILL");
assert.equal(f.fenced(), true);
assert.equal(f.triageKeys().length, 1);
assert.equal(fs.existsSync(f.file), false);
const status = await f.cli(["triage", "key", "status"]);
ok(status);
assert.match(status.stdout, new RegExp(`proxy fence: set[^\\n]*\\nkeys in the Triage namespace the file does not hold: ${id(f.triageKeys()[0])}\\nnext: restart the proxy, then mosaic proxy fence clear --proxy-restarted\\n$`));
refusal(await f.cli(["triage", "key", "issue"]), "proxy-uncertain");
ok(await f.cli(["proxy", "fence", "clear", "--proxy-restarted"]));
assert.equal(f.fenced(), false);
const stray = f.triageKeys()[0];
const r = await f.cli(["triage", "key", "issue"]);
ok(r);
assert.match(r.stdout, new RegExp(`removed keys this file did not hold: ${id(stray)}\\n$`));
assert.deepEqual(f.triageKeys(), [f.record().key]);
f.scan();
});
test("crash after the read-back, before the file write: no fence; status names the stray key; issue removes it", async (t) => {
const f = await fixture(t);
assert.equal((await f.crash(["triage", "key", "issue"], "write")).signal, "SIGKILL");
assert.equal(f.fenced(), false);
assert.equal(fs.existsSync(f.file), false);
const [stray] = f.triageKeys();
assert.match((await f.cli(["triage", "key", "status"])).stdout,
new RegExp(`^triage key: not issued\\n[^]*keys in the Triage namespace the file does not hold: ${id(stray)}\\nnext: mosaic triage key issue\\n$`));
ok(await f.cli(["triage", "key", "issue"]));
assert.deepEqual(f.triageKeys(), [f.record().key]);
// The same crash in rotate: the file keeps the old key, the stray new one is named, retire removes it.
const held = f.record();
assert.equal((await f.crash(["triage", "key", "rotate"], "write")).signal, "SIGKILL");
assert.deepEqual(f.record(), held);
const strayNew = f.triageKeys().find((k) => k !== held.key);
assert.match((await f.cli(["triage", "key", "status"])).stdout,
new RegExp(`proxy: holds the key\\nkeys in the Triage namespace the file does not hold: ${id(strayNew)}\\nnext: mosaic triage key retire\\n$`));
const retired = await f.cli(["triage", "key", "retire"]);
ok(retired);
assert.equal(retired.stdout, `triage key retire: removed ${id(strayNew)}\n`);
assert.deepEqual(f.triageKeys(), [held.key]);
f.scan();
});
test("file written but the old key not yet retired: status shows it due; a crash inside retire recovers on the next retire", async (t) => {
const f = await fixture(t);
ok(await f.cli(["triage", "key", "issue"]));
const first = f.record();
ok(await f.cli(["triage", "key", "rotate"]));
f.now = NOW + 121 * MIN;
assert.match((await f.cli(["triage", "key", "status"])).stdout, new RegExp(`retiring: ${first.keyId}, live until a retire after [^\\n]* \\(due\\)\\n[^]*next: mosaic triage key retire\\n$`));
// retire dies after the proxy dropped the key but before the file was rewritten.
assert.equal((await f.crash(["triage", "key", "retire"], "write")).signal, "SIGKILL");
assert.equal(f.state.keys.includes(first.key), false);
assert.equal(f.record().retiring.length, 1);
assert.match((await f.cli(["triage", "key", "status"])).stdout, /\(due\) \(not in the proxy list\)\n[^]*next: mosaic triage key retire\n$/);
const puts = f.state.puts.length;
const r = await f.cli(["triage", "key", "retire"]);
ok(r);
assert.equal(f.state.puts.length, puts);
assert.deepEqual(f.record().retiring, []);
// And a retire killed after its PUT leaves the fence, like any other write.
ok(await f.cli(["triage", "key", "rotate"]));
f.now += 121 * MIN;
assert.equal((await f.crash(["triage", "key", "retire"], "put")).signal, "SIGKILL");
assert.equal(f.fenced(), true);
refusal(await f.cli(["triage", "key", "retire"]), "proxy-uncertain");
ok(await f.cli(["proxy", "fence", "clear", "--proxy-restarted"]));
ok(await f.cli(["triage", "key", "retire"]));
assert.deepEqual(f.record().retiring, []);
assert.deepEqual(f.triageKeys(), [f.record().key]);
f.scan();
});
test("a file that cannot be written after the proxy changed is reported with its recovery", async (t) => {
const f = await fixture(t);
ok(await f.cli(["triage", "key", "status"]));
fs.mkdirSync(f.dir, { mode: 0o700 });
const r = await f.cli(["triage", "key", "issue"], { deps: { triageKeyHook: (stage) => { if (stage === "write") fs.chmodSync(f.dir, 0o755); } } });
refusal(r, "triage-key-unwritten", "the proxy list changed but ");
assert.match(r.stderr, /run mosaic triage key issue again, which clears what this run left\n$/);
assert.equal(f.triageKeys().length, 1);
fs.chmodSync(f.dir, 0o700);
ok(await f.cli(["triage", "key", "issue"]));
assert.deepEqual(f.triageKeys(), [f.record().key]);
f.scan();
});
test("crash after the temp file, before its rename: status counts it; the next verb removes it", async (t) => {
const f = await fixture(t);
assert.equal((await f.crash(["triage", "key", "issue"], "rename")).signal, "SIGKILL");
assert.equal(fs.existsSync(f.file), false);
const temps = fs.readdirSync(f.dir).filter((n) => n.endsWith(".tmp"));
assert.equal(temps.length, 1);
assert.match(temps[0], /^\.model\.\d+\.[0-9a-f]{12}\.tmp$/);
// The temp file holds the key the proxy now has; that is why it must go.
const [stray] = f.triageKeys();
assert.ok(fs.readFileSync(join(f.dir, temps[0]), "utf8").includes(stray));
const status = await f.cli(["triage", "key", "status"]);
ok(status);
assert.match(status.stdout, new RegExp(`leftover temp files in the triage secrets directory: 1 \\(the next issue, rotate or retire removes them\\)\\nkeys in the Triage namespace the file does not hold: ${id(stray)}\\nnext: mosaic triage key issue\\n$`));
// Something else in the directory is not a leftover and stays.
fs.writeFileSync(join(f.dir, "notes.tmp"), "", { mode: 0o600 });
ok(await f.cli(["triage", "key", "issue"]));
assert.deepEqual(fs.readdirSync(f.dir).sort(), ["model", "notes.tmp"]);
assert.deepEqual(f.triageKeys(), [f.record().key]);
// Retire, with nothing else to do, still removes a leftover.
assert.equal((await f.crash(["triage", "key", "rotate"], "rename")).signal, "SIGKILL");
ok(await f.cli(["triage", "key", "retire"]));
assert.deepEqual(fs.readdirSync(f.dir).sort(), ["model", "notes.tmp"]);
assert.doesNotMatch((await f.cli(["triage", "key", "status"])).stdout, /leftover/);
f.scan();
});
test("the receipts file is checked before the proxy changes; a receipt that fails after is named", async (t) => {
const receipts = (f) => join(f.root, "proxy", "mosaic-keys.receipts.jsonl");
const spoils = [
["mode", (f) => { fs.writeFileSync(receipts(f), "", { mode: 0o644 }); fs.chmodSync(receipts(f), 0o644); }, "the proxy receipts file mode is not 0600"],
["link", (f) => { fs.writeFileSync(join(f.root, "elsewhere"), "", { mode: 0o600 }); fs.symlinkSync(join(f.root, "elsewhere"), receipts(f)); }, "the proxy receipts file cannot be opened"],
["FIFO", (f) => assert.equal(spawnSync("mkfifo", ["-m", "600", receipts(f)]).status, 0), "the proxy receipts file cannot be opened"],
];
for (const [name, spoil, words] of spoils) {
const f = await fixture(t);
spoil(f);
refusal(await f.cli(["triage", "key", "issue"]), "triage-key-receipts-unsafe", `${words}; nothing was changed\n$`);
assert.equal(f.state.puts.length, 0, name);
assert.equal(f.fenced(), false, name);
assert.equal(fs.existsSync(f.file), false, name);
f.scan();
}
// Safe before the change, unsafe at the receipt: the change stands and the refusal says so.
const f = await fixture(t);
const r = await f.cli(["triage", "key", "issue"], { deps: { triageKeyHook: (stage) => { if (stage === "receipt") fs.chmodSync(receipts(f), 0o644); } } });
refusal(r, "triage-key-unrecorded", "the change was made but its receipt line was not written; run mosaic triage key status\n$");
assert.deepEqual(f.triageKeys(), [f.record().key]);
assert.equal(f.fenced(), false);
assert.equal(fs.readFileSync(receipts(f), "utf8"), "");
f.scan();
});
test("a directory sync that fails after the rename is named, and the receipt is still written", async (t) => {
const f = await fixture(t);
const r = await f.cli(["triage", "key", "issue"], { deps: { triageKeyHook: (stage) => { if (stage === "sync") throw new Error("EIO"); } } });
refusal(r, "triage-key-unsynced", `${f.file.replace(/[.]/g, "\\.")} was written but its directory could not be synced, so it may not survive a power loss; run mosaic triage key status\n$`);
const rec = f.record();
assert.deepEqual(f.triageKeys(), [rec.key]);
assert.deepEqual(f.receipts().map((e) => e.addedKeyIds), [[rec.keyId]]);
assert.equal(f.fenced(), false);
assert.match((await f.cli(["triage", "key", "status"])).stdout, /proxy: holds the key\nnext: nothing\n$/);
f.scan();
});
test("an unexpected error prints fixed words, never the error's own text", async (t) => {
const f = await fixture(t);
const secret = `mst-${tag(f.configDir)}-triage-${b64()}`;
SEEN.add(secret);
// Outside the proxy write: the verb's own fallback line.
const broken = { dataRoot: f.root, get proxy() { throw new Error(`boom ${secret}`); } };
for (const verb of VERBS) {
const r = await f.cli(["triage", "key", verb], { system: broken });
assert.equal(r.code, 3, verb);
assert.equal(r.stderr, "mosaic: triage-key-failed: the key verb stopped on an unexpected error; run mosaic triage key status\n");
}
// Inside the proxy write: the write's own fixed line, and the fence stays for a human.
const r = await f.cli(["triage", "key", "issue"], { deps: { triageKeyHook: (stage) => { if (stage === "put") throw new Error(`boom ${secret}`); } } });
refusal(r, "triage-key-failed", "the proxy write failed\n$");
assert.equal(f.fenced(), true);
f.scan();
});
// The org bus reconciles its own `mso-` namespace at start and a no-org bus its `msk-` one; a
// Triage key sits in neither, so both leave it. Stray keys in each namespace show the reconcile ran.
test("an org bus that starts and reconciles, and a no-org reconcile, both leave the Triage key alone", async (t) => {
const f = await fixture(t);
ok(await f.cli(["triage", "key", "issue"]));
const triage = f.record().key;
const strayOrg = `mso-${tag(f.configDir)}-demo-key-${b64()}`;
f.state.keys.push(strayOrg);
const rolesDir = rolesCopy(f.root), system = systemFor(f.root), doc = businessDoc(f.root, "demo");
doc.plugins = { ...doc.plugins, harness: ["pi"] };
const file = writeJson(join(f.configDir, "businesses", "demo.json"), doc);
assert.ok(file);
const business = loadBusiness("demo", { dir: f.configDir, rolesDir }), resolved = {};
for (const instance of Object.keys(business.roles)) resolved[instance] = resolveInstance({ system, business, instance });
fs.mkdirSync(join(f.root, "data"), { mode: 0o700 });
new Registry(join(f.root, "data"));
const bus = await startBroker({ dataRoot: join(f.root, "data"), businesses: { demo: busOrganization(business, resolved) },
organization: { dir: f.configDir, rolesDir, system }, proxy: { port: f.port, binary: "/fixture-unused" },
org: { id: "demo" }, instanceDataRoot: f.root, instanceConfigDir: f.configDir });
f.closers.push(() => bus.close());
const orgKey = (await bus.modelPreflight({ business: "demo", role: "chief" })).key;
assert.ok(orgKey.startsWith(`mso-${tag(f.configDir)}-demo-key-`));
assert.equal(f.state.keys.includes(strayOrg), false, "the org reconcile did not run");
assert.ok(f.state.keys.includes(triage), "the org bus removed the Triage key");
// A no-org reconcile on the same instance.
const strayAgent = `msk-${tag(f.configDir)}-${b64()}`;
f.state.keys.push(strayAgent);
const client = new ManagementClient({ baseUrl: `http://127.0.0.1:${f.port}`, key: MANAGE });
const keys = new ModelKeys({ credentials: { status: () => [], modelRecord: () => null }, client, configDir: f.configDir, baseUrl: `http://127.0.0.1:${f.port}` });
await keys.reconcile();
assert.equal(f.state.keys.includes(strayAgent), false, "the no-org reconcile did not run");
assert.ok(f.state.keys.includes(triage), "the no-org reconcile removed the Triage key");
// Triage still works under the shared lock while the org bus runs, and leaves the org key.
f.now += HOUR;
ok(await f.cli(["triage", "key", "rotate"]));
assert.ok(f.state.keys.includes(orgKey));
assert.match((await f.cli(["triage", "key", "status"])).stdout, /proxy: holds the key\n/);
f.scan();
});
test("scripts/mosaic routes triage key status with the instance's own config directory", (t) => {
const home = fs.mkdtempSync(join(tmpdir(), "tkm-"));
t.after(() => fs.rmSync(home, { recursive: true, force: true }));
const env = humanEnv({ HOME: home, MOSAIC_CONFIG: join(home, ".config/mosaic-tktest/config.json") });
const setup = spawnSync(join(REPO, "scripts/bootstrap.sh"), ["--instance", "tktest"], { env, encoding: "utf8" });
assert.equal(setup.status, 0, setup.stderr);
const r = spawnSync(join(REPO, "scripts/mosaic"), ["triage", "key", "status"], { env, encoding: "utf8", timeout: 60000 });
OUTPUTS.push(r.stdout, r.stderr);
assert.equal(r.status, 0, r.stderr);
assert.equal(r.stdout, `triage key: not issued\nfile: ${join(home, ".config/mosaic-tktest/secrets/triage/model")}\nproxy: not set up for this instance (no proxy.json)\nnext: set up the model proxy first (mosaic proxy init)\n`);
const refused = spawnSync(join(REPO, "scripts/mosaic"), ["triage", "key", "issue"], { env: { ...env, CLAUDECODE: "1" }, encoding: "utf8", timeout: 60000 });
assert.equal(refused.status, 3);
assert.match(refused.stderr, /found CLAUDECODE in the environment/);
});
test("no output of any verb in this file holds any key the stand-in saw", () => {
assert.ok(SEEN.size >= 20, `only ${SEEN.size} keys were seen`);
assert.ok(OUTPUTS.length >= 100);
for (const text of OUTPUTS) assert.equal(leaks(text), false);
});
+149
View File
@@ -0,0 +1,149 @@
// #1873 triage-route-store: `mosaic triage route show|set`, the owner's terminal verbs for the
// Triage route file (packages/webui/src/triage-route-store.mjs). Human verbs: an agent run is
// refused before anything is read (exit 3), as the other human verbs refuse it. `show` with no
// file says the route is not set and exits 0.
import { test } from "node:test";
import assert from "node:assert/strict";
import { spawnSync } from "node:child_process";
import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { run } from "../src/cli.mjs";
import { AGENT_MARKERS } from "../src/transport.mjs";
import { routePaths } from "../../webui/src/triage-route-store.mjs";
import { humanEnv, io } from "./helpers.mjs";
const REPO = new URL("../../../", import.meta.url).pathname;
const MOSAIC = join(REPO, "scripts/mosaic");
const NOW = new Date("2026-11-18T12:00:00.000Z");
const SET = ["triage", "route", "set", "--model", "glm-5", "--harness", "claude-code", "--cap", "200000", "--time-zone", "America/Chicago"];
function dataRoot(t) {
const d = mkdtempSync(join(tmpdir(), "tr-"));
t.after(() => rmSync(d, { recursive: true, force: true }));
return d;
}
async function cli(argv, d, env = humanEnv()) {
const s = io(env);
const code = await run(argv, s, { system: { dataRoot: d }, now: () => NOW });
return { code, stdout: s.out.text, stderr: s.err.text };
}
test("show with no route says it is not set and exits 0", async (t) => {
const d = dataRoot(t);
assert.deepEqual(await cli(["triage", "route", "show"], d), { code: 0, stdout: "triage route: not set\n", stderr: "" });
assert.equal(existsSync(routePaths(d).dir), false);
});
test("set writes the route; show reads it back", async (t) => {
const d = dataRoot(t);
const set = await cli(SET, d);
assert.equal(set.code, 0, set.stderr);
assert.equal(set.stdout, "triage route set: revision 1\n");
const shown = await cli(["triage", "route", "show"], d);
assert.equal(shown.code, 0);
assert.equal(shown.stdout, [
"triage route: revision 1",
"model: glm-5",
"harness: claude-code",
"cap: 200000 tokens a day, resets 00:00 America/Chicago, counted since 2026-11-18T12:00:00.000Z",
"updated: 2026-11-18T12:00:00.000Z by owner",
"",
].join("\n"));
const doc = JSON.parse(readFileSync(routePaths(d).file, "utf8"));
assert.equal(doc.updatedBy, "owner");
// --revision makes the write conditional on what show printed.
const five = ["triage", "route", "set", "--model", "glm-5", "--harness", "claude-code", "--cap", "5", "--time-zone", "America/Chicago", "--revision", "1"];
assert.equal((await cli(five, d)).code, 0);
assert.equal(JSON.parse(readFileSync(routePaths(d).file, "utf8")).cap.limit, 5);
const stale = await cli([...SET, "--revision", "1"], d);
assert.equal(stale.code, 3);
assert.match(stale.stderr, /^mosaic: triage-route-stale: /);
});
test("refused input exits 2 or 4 and writes nothing", async (t) => {
const d = dataRoot(t);
const without = (flag) => { const a = [...SET]; const i = a.indexOf(flag); a.splice(i, 2); return a; };
const swap = (flag, value) => { const a = [...SET]; a[a.indexOf(flag) + 1] = value; return a; };
const cases = [
[without("--model"), 4], [without("--harness"), 4], [without("--cap"), 4], [without("--time-zone"), 4],
[swap("--cap", "-1"), 2], [swap("--cap", "1e3"), 2], [swap("--cap", "01"), 2], [swap("--cap", "9007199254740993"), 2],
[swap("--time-zone", "Atlantis/Lost"), 2], [swap("--model", "Has Space"), 2],
[swap("--harness", "nonesuch"), 2], [swap("--harness", "../pi"), 2],
[[...SET, "--revision", "x"], 2], [[...SET, "--revision", "-1"], 2],
[[...SET, "--cap", "5"], 4], [[...SET, "--unknown", "1"], 4], [[...SET, "extra"], 4],
[["triage", "route", "show", "--model", "x"], 4], [["triage", "route", "show", "extra"], 4],
[["triage", "route"], 4], [["triage", "route", "remove"], 4], [["triage"], 4], [["triage", "key"], 4],
];
for (const [argv, want] of cases) {
const r = await cli(argv, d);
assert.equal(r.code, want, `${argv.join(" ")}: ${r.stderr}`);
assert.equal(r.stdout, "");
}
// An unknown option is named as one, and its value never reaches the message.
const unknown = await cli([...SET, "--unknown", "secret-value"], d);
assert.equal(unknown.code, 4);
assert.match(unknown.stderr, /^mosaic: unknown option\n/);
assert.doesNotMatch(unknown.stderr, /secret-value/);
assert.equal(existsSync(routePaths(d).file), false);
});
test("an unreadable store exits 3 on show and on set", async (t) => {
const d = dataRoot(t);
assert.equal((await cli(SET, d)).code, 0);
chmodSync(routePaths(d).file, 0o644);
for (const argv of [["triage", "route", "show"], [...SET, "--revision", "1"]]) {
const r = await cli(argv, d);
assert.equal(r.code, 3);
assert.match(r.stderr, /^mosaic: triage-route-unreadable: the Triage route store is unreadable: route\.json mode is not 0600\n$/);
}
});
test("an agent caller is refused before anything is read, for show and set", async (t) => {
const d = dataRoot(t);
for (const marker of AGENT_MARKERS) {
for (const argv of [["triage", "route", "show"], SET]) {
const r = await cli(argv, d, { ...humanEnv(), [marker]: "1" });
assert.equal(r.code, 3, marker);
assert.equal(r.stderr, `mosaic: refused: this runs only from a human shell, outside any agent run (found ${marker} in the environment)\n`);
}
}
assert.equal(existsSync(routePaths(d).dir), false);
});
test("scripts/mosaic routes triage to the verb; a marker in the process env refuses", (t) => {
const home = mkdtempSync(join(tmpdir(), "trm-"));
t.after(() => rmSync(home, { recursive: true, force: true }));
const env = humanEnv({ HOME: home, MOSAIC_CONFIG: join(home, ".config/mosaic-trtest/config.json") });
const setup = spawnSync(join(REPO, "scripts/bootstrap.sh"), ["--instance", "trtest"], { env, encoding: "utf8" });
assert.equal(setup.status, 0, setup.stderr);
const mosaic = (args, extra = {}) => spawnSync(MOSAIC, args, { env: { ...env, ...extra }, encoding: "utf8", timeout: 60000 });
const shown = mosaic(["triage", "route", "show"]);
assert.equal(shown.status, 0, shown.stderr);
assert.equal(shown.stdout, "triage route: not set\n");
const set = mosaic(SET.slice(0));
assert.equal(set.status, 0, set.stderr);
assert.equal(set.stdout, "triage route set: revision 1\n");
const dataDir = join(home, ".mosaic-trtest");
assert.equal(JSON.parse(readFileSync(routePaths(dataDir).file, "utf8")).model, "glm-5");
const refused = mosaic(["triage", "route", "show"], { CLAUDECODE: "1" });
assert.equal(refused.status, 3);
assert.match(refused.stderr, /found CLAUDECODE in the environment/);
assert.equal(refused.stdout, "");
});
test("a marker in this process's own environment refuses even when the command's env is clean", async (t) => {
const d = dataRoot(t);
for (const marker of AGENT_MARKERS) {
const saved = process.env[marker];
process.env[marker] = "1";
try {
for (const argv of [["triage", "route", "show"], SET]) {
const r = await cli(argv, d, humanEnv());
assert.equal(r.code, 3, marker);
assert.match(r.stderr, new RegExp(`found ${marker} in the environment`));
}
} finally { if (saved === undefined) delete process.env[marker]; else process.env[marker] = saved; }
}
assert.equal(existsSync(routePaths(d).dir), false);
});
+50 -3
View File
@@ -36,9 +36,9 @@
import { refusalGuidance } from "../../bus/src/refusals.mjs";
import { spawn } from "node:child_process";
import { setTimeout as delay } from "node:timers/promises";
import { chmodSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, closeSync } from "node:fs";
import { chmodSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, rmSync, closeSync } from "node:fs";
import { createServer, connect } from "node:net";
import { join } from "node:path";
import { basename, join } from "node:path";
import { fileURLToPath, pathToFileURL } from "node:url";
import { Client } from "../../bus/src/client.mjs";
import { LENGTH_FAILURE_NOTICE_PREFIX } from "./failure-notice.mjs";
@@ -384,13 +384,56 @@ export function toolServer({ path, tools, client, local }) {
});
}
// #1873 r127: exit 127 is the shell's "command not found". The turn's stderr then holds the
// shell's own line for it, the last one nearest the exit:
// bash X: line N: [exec: ]CMD: No such file or directory | [command ]not found
// dash X: N: [exec: ]CMD: not found
// env [/usr/bin/]env: 'CMD': No such file or directory
// Only those shapes count, so another program's missing file (cat: F: No such file…) doesn't.
// The answer is CMD's basename, which the person reads in the failure; never its host path, and
// nothing that isn't a plain program name. A run of 16 letters and digits looks like a key, not a
// program, so it stays in the run's private stderr.
const NOT_FOUND = [
/(?:^|: )line \d+: (?:exec: )?([^\s:]+): (?:(?:command )?not found|No such file or directory)$/,
/: \d+: (?:exec: )?([^\s:]+): not found$/,
/^(?:\S*\/)?env: ['\u2018]([^\s:'\u2019]+)['\u2019]: No such file or directory$/,
];
export function missingCommand(text) {
let name = null;
for (const line of String(text).split(/\r?\n/)) {
const m = NOT_FOUND.map((re) => re.exec(line)).find(Boolean);
if (m) name = basename(m[1]);
}
return name && /^[A-Za-z0-9._+-]{1,64}$/.test(name) && !/[A-Za-z0-9]{16}/.test(name) ? name : null;
}
// The last 16 KiB of a turn's stderr file from a line start, or "" when it can't be read.
const TAIL = 16384;
function stderrTail(path) {
let fd;
try {
fd = openSync(path, "r");
const size = fstatSync(fd).size, length = Math.min(size, TAIL);
const buf = Buffer.alloc(length);
readSync(fd, buf, 0, length, size - length);
const text = buf.toString("utf8");
// A window that starts mid-file starts mid-line; that partial line is dropped.
return size > TAIL ? text.slice(text.indexOf("\n") + 1) : text;
} catch {
return "";
} finally {
if (fd !== undefined) closeSync(fd);
}
}
// Run one turn. Resolves { ok, text, reason }.
function runTurn({ session, request, n, env, onChild }) {
const marker = session.turnMarker;
rmSync(marker, { force: true });
const turns = join(session.runDir, "turns");
mkdirSync(turns, { recursive: true, mode: 0o700 });
const errFd = openSync(join(turns, `${String(n).padStart(4, "0")}.stderr`), "wx", 0o600);
const errPath = join(turns, `${String(n).padStart(4, "0")}.stderr`);
const errFd = openSync(errPath, "wx", 0o600);
// Adapters are 0644 in the repository (the image sets the mode), so the
// host runs them through sh.
const child = spawn("/bin/sh", [session.adapter], {
@@ -461,6 +504,10 @@ function runTurn({ session, request, n, env, onChild }) {
if (status?.stopReason === "length" && status.hasText === false && status.hasToolCall === false)
return resolve({ ok: false, emptyLength: true, reason: "output limit reached while thinking before any answer or tool call" });
}
if (code === 127) {
const missing = missingCommand(stderrTail(errPath));
return resolve({ ok: false, reason: `adapter exited 127${missing ? ` (command not found: ${missing})` : ""}` });
}
if (code !== 0) return resolve({ ok: false, reason: signal ? `adapter killed by ${signal}` : `adapter exited ${code}` });
// A "marker" harness (row 65: the module's turnEnd()) writes the marker when its turn ends.
if (session.turnEnd === "marker" && !existsSync(marker)) return resolve({ ok: false, reason: `${session.harness} exited before the turn ended (no turn marker)` });
+83 -1
View File
@@ -13,7 +13,7 @@ import { join } from "node:path";
import { Store } from "../../bus/src/store.mjs";
import { Broker, BusError } from "../../bus/src/broker.mjs";
import { serve } from "../../bus/src/server.mjs";
import { EXIT, founderCheck, landingRequest, stateBlock, turnRequest, unslopCounts, unslopLog, unslopNotes } from "../src/runner.mjs";
import { EXIT, founderCheck, landingRequest, missingCommand, stateBlock, turnRequest, unslopCounts, unslopLog, unslopNotes } from "../src/runner.mjs";
import { typedTools } from "../src/tools.mjs";
import { resolvedFor, scratch } from "./helpers.mjs";
@@ -298,6 +298,88 @@ test("SIGKILL of the model child keeps base failure receipts through the real ad
assert.equal(records[1].body, records[0].body);
});
// #1873 r127: on the dev instance /usr/bin/claude is a wrapper that execs a binary outside /usr.
// The sandbox binds /usr only, so the wrapper starts and its target is missing: the shell exits
// 127 and the person read only "adapter exited 127". The reason now names the missing program.
test("r127 an adapter exit 127 names the program that wasn't found, through the real claude adapter", async t => {
const ctx = await setup(t, {session:{harness:"claude-code", turnEnd:"exit", adapter:new URL("../../../adapters/claude/adapter.sh", import.meta.url).pathname}});
const sessionFile = join(ctx.runDir, "session.json");
const session = JSON.parse(readFileSync(sessionFile, "utf8"));
const wrapper = join(ctx.dir, "bin", "claude");
mkdirSync(join(ctx.dir, "bin"));
writeFileSync(wrapper, `#!/bin/sh\nexport DISABLE_UPDATES=1\nexec ${join(ctx.dir, "not-mounted", "claude-code", "bin", "claude")} "$@"\n`, {mode:0o755});
session.harnessEnv = {MOSAIC_CLAUDE_BIN:wrapper, MOSAIC_THINKING:"low", MOSAIC_CLAUDE_SETTINGS:session.bundle.policy, MOSAIC_CLAUDE_MCP_CONFIG:session.bundle.tools};
writeFileSync(sessionFile, JSON.stringify(session));
ctx.inbox = [];
const r = startRunner(ctx.runDir, ctx.cap);
t.after(() => r.child.kill("SIGKILL"));
const sent = ctx.call(ctx.pm, "message.send", {to:"coder", body:"hello", class:"REQUEST"});
const [reply] = await until(replies(ctx));
await until(() => ctx.store.get("SELECT 1 FROM deliveries WHERE message=? AND op='read'", sent.id));
assert.equal(reply.body, "The turn failed: adapter exited 127 (command not found: claude)");
assert.doesNotMatch(reply.body, /not-mounted|\/bin\//, "the reason names the program, never its host path");
assert.match(r.stderr(), /failed: adapter exited 127 \(command not found: claude\)/);
r.child.kill("SIGTERM"); await r.exited;
});
test("r127 an adapter whose own command is missing names it; a 127 with no such line keeps the bare reason", async t => {
const ctx = await setup(t);
const adapter = join(ctx.dir, "adapter.sh");
writeFileSync(adapter, `case "$MOSAIC_REQUEST" in *QUIET*) echo "nothing useful" >&2; exit 127 ;; esac\nexec mosaic-r127-no-such-harness -p "$MOSAIC_REQUEST"\n`);
ctx.inbox = [];
const r = startRunner(ctx.runDir, ctx.cap);
t.after(() => r.child.kill("SIGKILL"));
ctx.call(ctx.pm, "message.send", {to:"coder", body:"one"});
ctx.call(ctx.pm, "message.send", {to:"coder", body:"QUIET"});
await until(() => replies(ctx)() && ctx.inbox.length >= 2);
assert.deepEqual(ctx.inbox.map(m => m.body), [
"The turn failed: adapter exited 127 (command not found: mosaic-r127-no-such-harness)",
"The turn failed: adapter exited 127",
]);
r.child.kill("SIGTERM"); await r.exited;
});
test("r127 missingCommand reads the shells' not-found lines and gives a safe basename only", () => {
assert.equal(missingCommand("/usr/bin/claude: line 4: /opt/claude-code/bin/claude: No such file or directory\nclaude adapter: invalid or incomplete model stream\n"), "claude");
assert.equal(missingCommand("/usr/bin/claude: 4: exec: /opt/claude-code/bin/claude: not found\n"), "claude");
assert.equal(missingCommand("/x/adapters/pi/adapter.sh: 140: exec: pi: not found\n"), "pi");
assert.equal(missingCommand("/x/adapter.sh: line 9: exec: pi: not found\n"), "pi");
assert.equal(missingCommand("sh: line 1: pi: command not found\n"), "pi");
assert.equal(missingCommand("/usr/bin/env: 'node': No such file or directory\n"), "node");
assert.equal(missingCommand("/usr/bin/env: ‘node’: No such file or directory\n"), "node");
// The last such line is the one nearest the exit.
assert.equal(missingCommand("a: 1: exec: first: not found\nb: 2: exec: second: not found\n"), "second");
assert.equal(missingCommand(""), null);
assert.equal(missingCommand("error: model refused\n"), null);
// A name that isn't a plain program name is left out, never echoed.
assert.equal(missingCommand("a: 1: exec: $(rm -rf x): not found\n"), null);
assert.equal(missingCommand(`a: 1: exec: ${"x".repeat(80)}: not found\n`), null);
// Review r127 P3-5: tokens without spaces reach the name check, and it refuses them.
assert.equal(missingCommand("a: 1: exec: $(id): not found\n"), null);
assert.equal(missingCommand("a: line 2: x;id: command not found\n"), null);
assert.equal(missingCommand("a: line 2: `id`: command not found\n"), null);
// P3-2: a long run of letters and digits looks like a key, not a program; it stays in stderr.
assert.equal(missingCommand("adapter.sh: line 3: sk-proj-abcDEF1234567890xyz: command not found\n"), null);
assert.equal(missingCommand("adapter.sh: line 3: 0123456789abcdef0123: command not found\n"), null);
// P3-1: only a shell's or env's own line counts; other programs' missing files don't.
assert.equal(missingCommand("cat: /nope/file: No such file or directory\n"), null);
assert.equal(missingCommand("w.sh: line 1: /opt/x/claude: No such file or directory\ncat: /run/state.json: No such file or directory\n"), "claude");
// P3-4: CRLF lines read the same.
assert.equal(missingCommand("sh: line 1: pi: command not found\r\n"), "pi");
});
test("r127 a not-found line cut by the 16 KiB stderr window is not read as a name", async t => {
const ctx = await setup(t, { session: { harness: 'pi', turnEnd: 'exit' } });
ctx.inbox = [];
// 52 + 16351 + 1 bytes: the 16 KiB window starts inside "claude", at "aude: No such file…".
writeFileSync(join(ctx.dir, 'adapter.sh'),
`printf 'x: line 1: /opt/x/claude: No such file or directory\\n' >&2\nhead -c 16351 /dev/zero | tr '\\0' 'z' >&2\nprintf '\\n' >&2\nexit 127\n`);
const r = startRunner(ctx.runDir, ctx.cap);
t.after(async () => { r.child.kill('SIGTERM'); await r.exited; });
const reply = await ask(ctx);
assert.equal(reply.body, "The turn failed: adapter exited 127");
});
// Claude's private stream reader owns model activity; final result stdout alone
// (even a synthetic success) must not cancel the model watchdog. Other adapters
// still need the stdout fallback when no streaming producer is installed.
+5 -5
View File
@@ -1,12 +1,12 @@
{
"version": "8.0.42",
"version": "8.0.79",
"archive": {
"asset": "CLIProxyAPI_8.0.42_linux_amd64.tar.gz",
"url": "https://github.com/router-for-me/CLIProxyAPI/releases/download/v8.0.42/CLIProxyAPI_8.0.42_linux_amd64.tar.gz",
"sha256": "1e10566fe0042ed5a9b80306cf296bf86a83de590cd967a8b177988b896c8d31"
"asset": "CLIProxyAPI_8.0.79_linux_amd64.tar.gz",
"url": "https://github.com/router-for-me/CLIProxyAPI/releases/download/v8.0.79/CLIProxyAPI_8.0.79_linux_amd64.tar.gz",
"sha256": "7cbb9709ed939ff3684e10592a45cc538ee82d5da759daa7e18c7e1dc3b32acd"
},
"binary": {
"sha256": "74661f8cf949977870231359e8bf4344e07946766a673c08fa25a3e5f72fc95e"
"sha256": "4968bd27b04f813849add020b95a26dc7abf3e30810b97d291c0d88f495fe601"
},
"panel": {
"version": "1.26.7",
+21 -1
View File
@@ -56,8 +56,28 @@ uses a new temp root and private network namespace, with made-up credentials,
and calls the page's bus verbs. If the page cannot pass against the new PIN,
the upgrade stops; Sage takes Q46's fallback to Jason through Mos.
A running instance takes a new PIN in three steps, in this order. First run
the new code: update the checkout or pinned copy the bus, Console and proxy
unit start from. The proxy unit runs `run.mjs` and reads `PIN` from the tree
it was installed from (`systemctl --user cat <unit>` shows it). If the new
code is in that same tree, a restart picks it up. If it is in another tree,
the unit keeps the old PIN until it is installed again from the new tree:
stop it, remove its unit file, then `mosaic proxy unit install` from the new
tree, because install never replaces a unit. Then run `mosaic proxy fetch` (or Fetch on the Console's
Model proxy settings), which installs the new release beside the old one
under `<dataRoot>/opt/cliproxyapi/<version>/`. Then restart the proxy with
`mosaic proxy unit restart`. Before the fetch, the proxy fails to start with
`proxy-install-missing`, and keeps failing until the fetch is done. Restart the bus and
Console as well so their status and Fetch use the new PIN. `proxy.json` keeps
the path from the PIN it was created under. That path stays valid, and the
proxy always runs the hash-verified install for the current PIN. Signed-in
accounts in `<dataRoot>/proxy/auth/` carry over. From 8.0.55 the proxy also
keeps a `kv.db` file in that directory, and 8.0.79 adds a `.codex-refresh/`
directory there once a Codex account renews. The old release directory can be
removed once the new one runs.
The native `/proxy` page uses human-only bus verbs; only the bus holds the
management client. On PIN 8.0.42, OAuth credentials are listed under
management client. On PIN 8.0.79, OAuth credentials are listed under
`/v8/management/credentials` and priority is patched as `{name, priority}`.
API-key groups are absent from that list: z.ai keys use the Claude-compatible
provider configuration at `/v8/management/config/api-keys/claude`, whose keys
+109 -3
View File
@@ -2,10 +2,12 @@
// `mosaic proxy status|unit|init-lock|fence clear --restart`. Host actions run here; init and
// the fence clear go to the bus, which decides them. Results and receipts carry labels, key IDs
// and process ids only: never a key, token, absolute path or upstream text.
import fs from 'node:fs';
import { homedir } from 'node:os';
import { fetchPinned } from './fetch.mjs';
import { PIN } from './common.mjs';
import { releaseState, initState, fenceState, initLockStatus, clearInitLock, appendReceipt, recentReceipts, createUnitControl, FILE_LABELS } from './admin.mjs';
import { localRide, riddenOrgs } from './ride.mjs';
import { releaseState, initState, fenceState, initLockStatus, clearInitLock, appendReceipt, recentReceipts, receiptsText, createUnitControl, FILE_LABELS } from './admin.mjs';
export const proxyCode = (error, fallback) => (/^proxy-[a-z-]+$/.test(error?.code ?? '') ? error.code : fallback);
const failure = code => Object.assign(new Error(code), { code });
@@ -13,7 +15,12 @@ const failure = code => Object.assign(new Error(code), { code });
// `buses()` proves the init-lock condition "bus stopped" ({stopped, running:[label]}).
// `orgs()` lists the organizations this proxy serves: [{id, catalogue}]. `unit` and `fetch` are
// (and `pin`) seams for tests; the defaults run the real proxy-service.sh, systemctl and pinned fetch.
export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir = null, unit = null, fetch = fetchPinned, buses, orgs = async () => [], now = () => new Date(), env = process.env, pin = PIN }) {
// #1873 ride-default: `riders()` lists the owner's active organizations for Ride all, read locally:
// [{id, fixture, cliproxy, changes, call, status}] where `changes` is the text of the organization's
// change log, `call(verb, args)` reaches its bus as the owner and `status()` is its bus status. `ownerModels()` answers
// {proxy, riding, models} from the riding buses' catalogues. `move(id, models, principal)` moves a
// stopped fixture organization to the owner's models through the organization service.
export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir = null, unit = null, fetch = fetchPinned, buses, orgs = async () => [], riders = async () => [], ownerModels = async () => ({ proxy: false, riding: false, models: [] }), move = null, now = () => new Date(), env = process.env, pin = PIN }) {
const port = () => { try { return initState(configDir, dataRoot).settings?.port ?? null; } catch { return null; } };
const control = unit ?? createUnitControl({ instance, unitDir, port, env });
let job = { state: 'idle', step: null, receipt: null, error: null };
@@ -30,6 +37,54 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
async function unitStatus() {
try { return await control.status(); } catch (error) { return { unit: control.unit, installed: false, active: 'unknown', healthy: false, error: proxyCode(error, 'proxy-unit-failed') }; }
}
// The organizations this proxy's own receipts show cliproxy was or may have been on (riddenOrgs).
// No receipt file yet is none; a file that fails receiptsText's check, or holds a line that does
// not parse, is null, and localRide skips every organization without cliproxy as unreadable.
function ridden() {
const ids = riddenOrgs(receiptsText(dataRoot));
return id => (ids === null ? null : ids.has(id));
}
const decide = (rider, wasRidden) => localRide({ ...rider, ridden: wasRidden(rider.id) });
// Stopped is the organization admin page's test (org-admin bus stop): a bus status with no
// process id. A status that cannot be read, or a rider with no status, is not stopped.
async function stopped(rider) {
if (typeof rider.status !== 'function') return false;
try { return !Number.isSafeInteger((await rider.status())?.pid); } catch { return false; }
}
const failCode = error => (/^[a-z][a-z-]{0,63}$/.test(error?.code ?? '') ? error.code : 'failed');
// Ride all, one organization: the local rules first, then the organization's bus, which must
// answer and must hold the proxy client. The bus decides the write (plugins.set) as it would
// for the owner on the Settings page. The answer names a reason, never bus or upstream text.
// A ride-intent receipt is on disk before plugins.set is sent; with no receipt there is no write.
// When plugins.set fails and the bus then shows no cliproxy, a ride-not-added receipt clears that
// intent. Any other failure leaves it: the add may have happened.
async function rideOne(rider, wasRidden) {
const id = rider.id, local = decide(rider, wasRidden);
if (local === 'fixture') return { id, outcome: 'fixture', running: !(await stopped(rider)) };
if (local !== 'ready') return { id, outcome: local === 'already' ? 'already' : 'skipped', reason: local };
let current;
try { current = await rider.call('plugins'); } catch { return { id, outcome: 'skipped', reason: 'bus-down' }; }
try { await rider.call('proxy.accounts'); } catch (error) { return { id, outcome: 'skipped', reason: error?.code === 'not-configured' ? 'no-proxy-client' : 'proxy-check-failed' }; }
const providers = Array.isArray(current?.plugins?.['model-provider']) ? current.plugins['model-provider'] : [];
if (providers.includes('cliproxy')) return { id, outcome: 'already' };
// The receipts are read again here: a removal saved while this run worked on earlier
// organizations is on file now, and the decision above came from the run's first read.
const now = ridden()(id);
if (now !== false) return { id, outcome: 'skipped', reason: now === null ? 'unreadable' : 'removed' };
try { receipt({ op: 'ride-intent', org: id }); } catch { return { id, outcome: 'skipped', reason: 'not-recorded' }; }
try { await rider.call('plugins.set', { revision: current.revision, plugins: { 'model-provider': [...providers, 'cliproxy'] } }); }
catch (error) {
try {
const after = await rider.call('plugins');
if (Array.isArray(after?.plugins?.['model-provider']) && !after.plugins['model-provider'].includes('cliproxy')) receipt({ op: 'ride-not-added', org: id });
} catch { /* unknown outcome: the intent stands */ }
return { id, outcome: 'failed', reason: failCode(error) };
}
return { id, outcome: 'added' };
}
async function rideSummary() {
try { const wasRidden = ridden(); return (await riders()).map(r => ({ id: r.id, state: decide(r, wasRidden) })); } catch { return null; }
}
function nextSteps({ release, init, unitState, fence, lock }) {
if (!release.fetched || release.problem) return ['fetch'];
if (lock.present) return lock.clearable ? ['init-lock-clear'] : ['init-lock-wait'];
@@ -54,6 +109,10 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
const lock = init.lock ? initLockStatus({ configDir, dataRoot, buses: await buses() }) : { present: false, clearable: false, blockers: [] };
let organizations = null;
try { organizations = await orgs(); } catch { organizations = null; }
const ride = await rideSummary();
const next = nextSteps({ release, init, unitState, fence, lock });
// Ride all comes after the proxy runs with no fence, while an organization can still ride.
if (next[0] === 'accounts' && ride?.some(r => r.state === 'ready' || r.state === 'fixture')) next.push('ride-all');
return {
release: { version: release.version, panelVersion: release.panelVersion, fetched: release.fetched, verified: release.verified, problem: release.problem },
init: {
@@ -71,7 +130,8 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
// Ruling 8: the system config holds one proxy per instance; an organization's own proxy
// needs a config format that does not exist yet.
ownProxy: { available: false, state: 'not built', reason: 'This instance has one shared proxy. A separate proxy per organization is not built yet.' },
next: nextSteps({ release, init, unitState, fence, lock }),
ride,
next,
};
},
// Runs in the background; the page polls status for its step and receipt.
@@ -133,6 +193,52 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
return { cleared: result.cleared === true, receipt: receipt({ op: 'fence.clear', cleared: result.cleared === true, evidence: result.evidence ?? null }) };
});
},
// Ride all: adds cliproxy to each organization that can take it, and names every one it skips.
// Fixture organizations are listed, not changed: moving one spends real tokens, so it is a
// separate confirmed action (rideMove).
async rideAll() {
return exclusive('ride-all', async () => {
const list = await riders(), wasRidden = ridden();
const results = [];
for (const rider of list) results.push(await rideOne(rider, wasRidden));
const added = results.filter(r => r.outcome === 'added').map(r => r.id);
const skipped = results.filter(r => r.outcome === 'skipped' || r.outcome === 'failed').map(r => ({ id: r.id, reason: r.reason }));
const fixtures = results.filter(r => r.outcome === 'fixture').map(r => ({ id: r.id, running: r.running }));
const already = results.filter(r => r.outcome === 'already').map(r => r.id);
// Each add already left its ride-intent receipt, so a summary that cannot be written still
// answers what happened, with no receipt.
let summary = null;
try { summary = receipt({ op: 'ride-all', added, skipped, fixtures: fixtures.map(f => f.id) }); } catch { summary = null; }
return { added, already, skipped, fixtures, receipt: summary };
});
},
// Moves one stopped fixture organization to the owner's models. Its bus is refused at start
// beside a real proxy, so the organization service writes its document (the same whole-document
// update the organization's admin page uses); the owner starts its bus afterwards.
async rideMove({ org, principal } = {}) {
return exclusive('ride-move', async () => {
const rider = (await riders()).find(r => r.id === org);
if (!rider) return { org, moved: false, reason: 'unknown' };
const local = decide(rider, ridden());
if (local !== 'fixture') return { org, moved: false, reason: local };
if (!(await stopped(rider))) return { org, moved: false, reason: 'bus-running' };
if (typeof move !== 'function') return { org, moved: false, reason: 'not-available' };
const owner = await ownerModels();
if (owner?.proxy !== true) return { org, moved: false, reason: 'no-proxy' };
if (owner.riding !== true) return { org, moved: false, reason: 'no-riding-bus' };
let result;
try { result = await move(org, owner.models, principal); }
catch (error) { result = { moved: false, reason: failCode(error) }; }
if (!result?.moved) return { org, moved: false, reason: result?.reason ?? 'failed' };
return { org, moved: true, model: result.model, receipt: receipt({ op: 'ride-move', org, model: result.model }) };
});
},
// The organization admin page calls this before it saves a document that drops cliproxy from
// the model providers, and saves nothing when it throws. Ride all then leaves that organization off.
rideRemoved(org) {
if (typeof org !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(org)) throw failure('proxy-org-invalid');
return receipt({ op: 'ride-removed', org });
},
async initLockClear() {
return exclusive('init-lock-clear', async () => ({ receipt: clearInitLock({ configDir, dataRoot, buses: await buses(), now }) }));
},
+20
View File
@@ -107,6 +107,26 @@ export function appendReceipt(dataRoot, record) {
return record;
}
// A file's text, read the way fenceState checks the fence file: opened without following a symlink
// (and without blocking on a FIFO), a regular file the Console's own user owns, with none of the
// `mask` permission bits. A missing file throws its ENOENT; any other failure throws
// proxy-file-refused. `uid` is a test seam.
export function ownedText(file, { mask = 0o077, uid = process.getuid() } = {}) {
const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
try {
const stat = fs.fstatSync(fd);
if (!stat.isFile() || stat.uid !== uid || (stat.mode & mask)) throw Object.assign(new Error('proxy-file-refused'), { code: 'proxy-file-refused' });
return fs.readFileSync(fd, 'utf8');
} finally { fs.closeSync(fd); }
}
// The whole receipt file's text for Ride all, which decides from it (ownedText, no group or other
// bits). No file yet answers ''; anything else that fails answers null, and the caller treats every
// organization without cliproxy as unreadable.
export function receiptsText(dataRoot, { uid = process.getuid() } = {}) {
try { return ownedText(receiptFile(dataRoot), { uid }); } catch (error) { return error?.code === 'ENOENT' ? '' : null; }
}
// The last few receipts, oldest first, for the page after a reload. Reads only the file's tail and
// skips a line that does not parse (a torn last write). Receipts never hold a key or a body.
export function recentReceipts(dataRoot, limit = 10) {
+166
View File
@@ -0,0 +1,166 @@
// #1873 ride-default slice 1: the rules for "Ride all", which adds the instance's model proxy
// (the cliproxy model provider) to the owner's existing organizations. Pure functions: the
// Console wiring (webui cli.mjs) reads each organization and its bus, and admin-control runs them.
import { usableModel } from '../../plugins/model-provider/cliproxy/index.mjs';
export { usableModel };
const has = (list, name) => Array.isArray(list) && list.includes(name);
// The model providers one change-log change shows before and after, by the change's path: the
// list itself, the plugins object, or the whole document. Any other path shows none.
function providersOf(change) {
const at = value => change?.path === 'plugins.model-provider' ? value
: change?.path === 'plugins' ? value?.['model-provider']
: change?.path === '' ? value?.plugins?.['model-provider'] : undefined;
return [at(change?.old), at(change?.new)];
}
const touchesProviders = path => path === '' || path === 'plugins' || path === 'plugins.model-provider';
// What the organization's change log shows of cliproxy, from its committed writes: `removed` when
// a write took it off, `seen` when any write shows it on the organization before or after, or wrote
// the providers without logging their values (a paths-only entry). A log that cannot be read
// answers null, and the caller skips the organization as unreadable.
export function cliproxyHistory(text) {
if (typeof text !== 'string') return null;
let removed = false, seen = false;
try {
for (const line of text.split('\n')) {
if (!line.trim()) continue;
const event = JSON.parse(line);
if (event?.state !== 'committed' || !Array.isArray(event.changes)) continue;
for (const change of event.changes) {
if (!touchesProviders(change?.path)) continue;
if (!Object.hasOwn(change, 'old') && !Object.hasOwn(change, 'new')) { seen = true; continue; }
const [before, after] = providersOf(change);
if (has(before, 'cliproxy') && !has(after, 'cliproxy')) removed = true;
if (has(before, 'cliproxy') || has(after, 'cliproxy')) seen = true;
}
}
return { removed, seen };
} catch { return null; }
}
export function cliproxyRemoved(text) { const h = cliproxyHistory(text); return h === null ? null : h.removed; }
// The organizations the proxy's own receipts (proxy-admin.jsonl) show cliproxy was or may have
// been on: each ride-all receipt's added list, each ride-move's org, each ride-removed's org (the
// organization admin page writes one before it saves a document without cliproxy), and each
// ride-intent's org (Ride all writes one before each plugins.set) unless a later ride-not-added for
// that organization shows the bus did not take it. Any line that does not parse, and any ride
// record of the wrong shape, answers null: the caller then skips every organization without
// cliproxy as unreadable. Text that is not a string answers null too.
const RIDE_ORG = new Set(['ride-move', 'ride-removed', 'ride-intent', 'ride-not-added']);
export function riddenOrgs(text) {
if (typeof text !== 'string') return null;
const ids = new Set(), pending = new Set();
for (const line of text.split('\n')) {
if (!line.trim()) continue;
let r; try { r = JSON.parse(line); } catch { return null; }
if (!r || typeof r !== 'object' || Array.isArray(r)) return null;
if (r.op === 'ride-all') {
if (!Array.isArray(r.added) || !r.added.every(id => typeof id === 'string')) return null;
for (const id of r.added) ids.add(id);
} else if (RIDE_ORG.has(r.op)) {
if (typeof r.org !== 'string') return null;
if (r.op === 'ride-intent') pending.add(r.org);
else if (r.op === 'ride-not-added') pending.delete(r.org);
else ids.add(r.org);
}
}
for (const id of pending) ids.add(id);
return ids;
}
// The local part of the decision, with no bus call: what Ride all does with one organization
// before it asks the organization's bus anything. An organization that uses cliproxy now (and is
// not a fixture organization) is already riding, whatever its history. One without cliproxy now
// that had it, or may have had it, is removed: its change log or the proxy's receipts show it
// (`ridden` is true from the receipts, null when they cannot be read).
export function localRide({ fixture, cliproxy, changes, ridden = false }) {
if (typeof fixture !== 'boolean' || typeof cliproxy !== 'boolean') return 'unreadable';
if (cliproxy && !fixture) return 'already';
const history = cliproxyHistory(changes);
if (history === null || (ridden === null && !cliproxy)) return 'unreadable';
if (history.removed || (!cliproxy && (ridden === true || history.seen))) return 'removed';
if (fixture) return 'fixture';
return 'ready';
}
// One organization as Ride all reads it, without its bus: `read()` gives its document and
// `readLog()` the text of its change log. A document that cannot be read leaves `fixture` and
// `cliproxy` undefined, a log that does not exist yet is empty, and any other log failure is null;
// localRide names either as unreadable. `isFixture(doc)` is the CLI's own fixture test.
export function readRider({ id, read, readLog, isFixture }) {
let doc = null, changes = null;
try { doc = read(); } catch {}
try { changes = readLog(); } catch (e) { changes = e?.code === 'ENOENT' ? '' : null; }
const ok = !!doc && typeof doc === 'object';
return { id, fixture: ok ? isFixture(doc) === true : undefined,
cliproxy: ok ? (Array.isArray(doc.plugins?.['model-provider']) ? doc.plugins['model-provider'] : []).includes('cliproxy') : undefined, changes };
}
// The owner's models: `proxy` is true when the instance's proxy.json names a port. Each organization
// that lists cliproxy is asked for its routes at once, so a hung bus costs one timeout, not one each.
// It rides when its bus answers a ready catalogue; the models are the cliproxy rows those
// catalogues list, once each.
export async function ownerModelsFrom({ proxy, riders }) {
if (proxy !== true) return { proxy: false, riding: false, models: [] };
const catalogues = await Promise.all((Array.isArray(riders) ? riders : []).filter(r => r?.cliproxy === true)
.map(async r => { try { return (await r.call('routes'))?.catalogue; } catch { return null; } }));
const models = new Map(); let riding = false;
for (const catalogue of catalogues) {
if (catalogue?.status !== 'ready' || !Array.isArray(catalogue.models)) continue;
riding = true;
// A key two buses list keeps the first usable row: one bus's stale row does not hide the model.
for (const m of catalogue.models) {
if (m?.module !== 'cliproxy' || typeof m.key !== 'string') continue;
if (!models.has(m.key) || (!usableModel(models.get(m.key)) && usableModel(m))) models.set(m.key, m);
}
}
return { proxy: true, riding, models: [...models.values()] };
}
// The owner's model for an organization: the first usable catalogue model from claude, else
// the first usable one, that serves every harness in `harnesses`.
export function pickModel(models, harnesses = []) {
const fits = (Array.isArray(models) ? models : []).filter(m => usableModel(m) && harnesses.every(h => m.harnesses.includes(h)));
return fits.find(m => m.upstream === 'claude') ?? fits[0] ?? null;
}
// A fixture organization moved to the owner's models: the fixture model provider becomes
// cliproxy, each fixture model entry goes, and every role that used one uses the owner's model.
// Answers { doc, model } or { reason } when no catalogue model serves the roles' harnesses.
export function fixtureMove(doc, models) {
const next = structuredClone(doc);
const fixtureKeys = Object.entries(next.launch?.models ?? {}).filter(([, m]) => m?.module === 'fixture').map(([key]) => key);
const uses = [];
const visit = vars => {
if (!vars || typeof vars !== 'object') return;
for (const prefix of ['', 'fallback.']) if (fixtureKeys.includes(vars[prefix + 'model'])) uses.push({ vars, prefix });
};
// A model is an agent-layer var: an organization's roles and each project's own agents carry one.
for (const role of Object.values(next.roles ?? {})) visit(role?.vars);
for (const project of Object.values(next.projects ?? {})) for (const agent of Object.values(project?.agents ?? {})) visit(agent?.vars);
const harnesses = [...new Set(uses.map(({ vars, prefix }) => vars[prefix + 'harness']).filter(h => typeof h === 'string'))];
const model = pickModel(models, harnesses);
if (!model) return { reason: 'no-model' };
for (const key of fixtureKeys) delete next.launch.models[key];
next.launch = next.launch ?? {}; next.launch.models = next.launch.models ?? {};
next.launch.models[model.key] = { provider: model.provider, model: model.model, module: 'cliproxy', upstream: model.upstream };
for (const { vars, prefix } of uses) vars[prefix + 'model'] = model.key;
const providers = (next.plugins?.['model-provider'] ?? []).filter(n => n !== 'fixture');
next.plugins = { ...(next.plugins ?? {}), 'model-provider': providers.includes('cliproxy') ? providers : [...providers, 'cliproxy'] };
return { doc: next, model };
}
// The move itself, through the organization service's existing whole-document update: read,
// change, validate, then write only if the revision read is still current. Owner-only twice:
// the Console route admits only the instance owner, and the service checks `ctx.principal`.
export async function moveFixtureOrg({ service, ctx, id, models }) {
const shown = await service.showOrg(ctx, id);
const moved = fixtureMove(shown.doc, models);
if (moved.reason) return { moved: false, reason: moved.reason };
const checked = await service.validateOrg(moved.doc);
if (!checked?.ok) return { moved: false, reason: 'invalid' };
await service.updateOrg(ctx, id, moved.doc, { ifRevision: shown.revision });
return { moved: true, model: moved.model.key };
}
+13 -2
View File
@@ -7,12 +7,23 @@ export function installPaths(dataRoot, pin = PIN) {
const dir = path.join(dataRoot, 'opt', 'cliproxyapi', pin.version);
return { dir, binary: path.join(dir, 'cli-proxy-api'), panel: path.join(dir, 'static', 'management.html') };
}
// proxy.json records the install path from the PIN it was created under, and nothing
// rewrites it. After a PIN bump an earlier release's path under this data root stays valid
// and reads as the current pinned path. The runner executes only the hash-verified pinned
// install, never the recorded path, so an old value selects nothing.
const releasePath = (dataRoot, binary) => {
const base = path.join(dataRoot, 'opt', 'cliproxyapi') + path.sep;
if (typeof binary !== 'string' || !binary.startsWith(base)) return false;
const [version, file, ...rest] = binary.slice(base.length).split(path.sep);
return rest.length === 0 && file === 'cli-proxy-api' && /^\d{1,4}\.\d{1,4}\.\d{1,6}$/.test(version);
};
export function validateProxy(value, dataRoot, pin = PIN) {
const pinned = installPaths(dataRoot, pin).binary;
if (!value || typeof value !== 'object' || Array.isArray(value)
|| Object.keys(value).some(k => !['binary', 'port', 'rotateGraceMinutes', 'firstOutputSeconds'].includes(k))
|| !Number.isInteger(value.port) || value.port < 1024 || value.port > 65535 || value.port === 8317
|| value.binary !== installPaths(dataRoot, pin).binary) refuse('proxy-config-invalid');
return { port: value.port, binary: value.binary, ...proxyTiming(value) };
|| (value.binary !== pinned && !releasePath(dataRoot, value.binary))) refuse('proxy-config-invalid');
return { port: value.port, binary: pinned, ...proxyTiming(value) };
}
export function loadProxy(configDir, dataRoot) {
const file = path.join(configDir, 'proxy.json');
@@ -1,4 +1,4 @@
// P4 pinned8.0.42 regression: absent Claude provider config is HTTP404.
// P4 regression since PIN 8.0.42 (still so on 8.0.79): absent Claude provider config is HTTP 404.
// Normalize only that fixed GET; all other methods/endpoints/statuses refuse.
import test from 'node:test';
import assert from 'node:assert/strict';
@@ -13,3 +13,13 @@ for (const [field, maximum, code] of [['rotateGraceMinutes', 1440, 'proxy-rotate
assert.throws(() => validateProxy({ ...base, [field]: value }, dataRoot), e => e.code === code);
});
}
// #1873 PIN bump: a sidecar written under an earlier PIN keeps the instance config valid.
test('a proxy.json written under an earlier PIN reads as the current pinned path', () => {
const old = { ...base, binary: '/fixture-data/opt/cliproxyapi/8.0.42/cli-proxy-api' };
assert.deepEqual(validateProxy(old, dataRoot), base);
assert.deepEqual(validateProxy({ ...old, rotateGraceMinutes: 60 }, dataRoot), { ...base, rotateGraceMinutes: 60 });
});
for (const binary of ['/bad', '/fixture-data/opt/cliproxyapi/8.0.42/other', '/fixture-data/opt/cliproxyapi/latest/cli-proxy-api',
'/fixture-data/opt/cliproxyapi/8.0.42/x/cli-proxy-api', '/fixture-data/opt/cliproxyapi/../cliproxyapi/8.0.42/cli-proxy-api',
'/other-data/opt/cliproxyapi/8.0.42/cli-proxy-api', '/fixture-data/opt/cliproxyapi/8.0/cli-proxy-api', 7])
test(`proxy-config-invalid: binary ${JSON.stringify(binary)}`, () => assert.throws(() => validateProxy({ ...base, binary }, dataRoot), e => e.code === 'proxy-config-invalid'));
@@ -1,4 +1,4 @@
// P4 client contract; endpoint/payload cases are probe-pending on PIN8.0.42.
// P4 client contract; endpoint/payload cases were probe-pending on PIN 8.0.42.
// Catches management key/body/query values leaking into receipts, redirects/retries.
import test from 'node:test';
import assert from 'node:assert/strict';
@@ -0,0 +1,134 @@
// #1873 ride-default slice 1: once Ride all adds the model proxy to an organization, a fenced
// proxy refuses each of that organization's launches with proxy-uncertain, a direct anthropic
// route included. A real organization bus bound to the instance's proxy, a loopback stand-in for
// the proxy's management API (made-up key, kept in this test's memory), and the real Ride all.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import http from 'node:http';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { startBroker } from '../../bus/src/runtime.mjs';
import { busOrganization } from '../../bus/src/organization-context.mjs';
import { createProxyLock } from '../../bus/src/proxy-lock.mjs';
import { Registry } from '../../seat/src/session.mjs';
import { loadBusiness } from '../../organization/src/organization-config.mjs';
import { resolveInstance } from '../../organization/src/resolve.mjs';
import { businessDoc, rolesCopy, systemFor, writeJson } from '../../organization/tests/helpers.mjs';
import { createProxyAdmin } from '../src/admin-control.mjs';
const MANAGE = 'ride-fence-manage';
async function ridingBus(t) {
const root = fs.mkdtempSync(join(tmpdir(), 'ride-fence-')), configDir = join(root, 'config');
fs.mkdirSync(join(configDir, 'secrets'), { recursive: true, mode: 0o700 });
fs.mkdirSync(join(root, 'proxy'), { mode: 0o700 });
let keys = ['msk-ride-fence-sentinel'];
const server = http.createServer(async (req, res) => {
const chunks = []; for await (const c of req) chunks.push(c);
if (req.headers.authorization !== `Bearer ${MANAGE}`) { res.writeHead(401); res.end('{}'); return; }
if (req.url === '/v8/management/config/access/api-keys') {
if (req.method === 'PUT') keys = JSON.parse(Buffer.concat(chunks));
res.end(JSON.stringify(req.method === 'GET' ? keys : { status: 'ok' })); return;
}
if (req.url.startsWith('/v8/management/credentials')) { res.end(JSON.stringify({ files: [], observed_at: '2026-11-19T00:00:00Z' })); return; }
if (req.url.startsWith('/v8/management/config/api-keys/')) { res.end('[]'); return; }
res.writeHead(404); res.end('{}');
});
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
const port = server.address().port;
const rolesDir = rolesCopy(root), system = systemFor(root), doc = businessDoc(root, 'demo');
// A direct anthropic route and no model provider: before Ride all, no launch asks the proxy.
doc.plugins = { ...doc.plugins, harness: ['pi'] };
doc.launch.models['claude-opus-5-5'] = { provider: 'anthropic', model: 'claude-opus-5-5' };
doc.roles.coder.vars = { ...doc.roles.coder.vars, harness: 'pi', model: 'claude-opus-5-5', thinking: 'low' };
writeJson(join(configDir, 'businesses', 'demo.json'), doc);
fs.writeFileSync(join(configDir, 'secrets', 'proxy-management.key'), MANAGE, { mode: 0o600 });
const business = loadBusiness('demo', { dir: configDir, rolesDir }), resolved = {};
for (const instance of Object.keys(business.roles)) resolved[instance] = resolveInstance({ system, business, instance });
fs.mkdirSync(join(root, 'data'), { mode: 0o700 }); new Registry(join(root, 'data'));
const bus = await startBroker({ dataRoot: join(root, 'data'), businesses: { demo: busOrganization(business, resolved) },
organization: { dir: configDir, rolesDir, system }, proxy: { port, binary: '/fixture-unused' },
org: { id: 'demo' }, instanceDataRoot: root, instanceConfigDir: configDir });
t.after(async () => { await bus.close(); server.closeAllConnections(); await new Promise(r => server.close(r)); fs.rmSync(root, { recursive: true, force: true }); });
const human = bus.broker.bindHuman({ business: 'demo', human: 'jason', via: 'cli', outsideAgent: true });
const call = async (verb, args = {}) => bus.broker.request(human, { verb, args });
const lock = createProxyLock({ stateDir: join(root, 'proxy'), identity: `${configDir}:${port}` });
const admission = async () => {
const current = JSON.parse(fs.readFileSync(join(configDir, 'businesses', 'demo.json'), 'utf8'));
const revision = (await call('plugins')).revision, entry = current.launch.models['claude-opus-5-5'];
return bus.modelAdmission({ business: 'demo', instance: 'coder', modelKey: 'claude-opus-5-5', harness: 'pi', revision, entry,
provider: entry.provider, model: entry.model, account: null, route: 'primary', transport: null });
};
return { root, configDir, bus, call, lock, admission, doc: () => JSON.parse(fs.readFileSync(join(configDir, 'businesses', 'demo.json'), 'utf8')) };
}
test('a fenced proxy refuses each riding organization\'s launches with proxy-uncertain, direct anthropic included', async t => {
const b = await ridingBus(t);
const dir = fs.mkdtempSync(join(tmpdir(), 'ride-fence-admin-')); t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
const admin = createProxyAdmin({ dataRoot: dir, configDir: dir, unit: { status: async () => ({}) }, buses: async () => [], fetch: async () => ({}),
riders: async () => [{ id: 'demo', fixture: false, cliproxy: (b.doc().plugins['model-provider'] ?? []).includes('cliproxy'), changes: '', call: b.call }] });
const ride = await admin.rideAll();
assert.deepEqual(ride.added, ['demo'], JSON.stringify(ride));
assert.deepEqual(b.doc().plugins['model-provider'], ['cliproxy']);
assert.equal(b.doc().launch.models['claude-opus-5-5'].module, undefined, 'the direct anthropic route stays as it was');
await b.lock.run(async () => b.lock.fence({ org: 'demo', op: 'ride-fence-test' }));
assert.deepEqual(await b.admission(), { allow: false, code: 'proxy-uncertain' });
assert.deepEqual((await admin.rideAll()).already, ['demo'], 'a second Ride all leaves a riding organization alone');
});
// The launcher half: on an instance with a model proxy, a direct anthropic route never asks the
// bus's admission until the organization lists a model provider. After Ride all it does, so the
// fenced answer above refuses the launch before any run exists.
test('after Ride all the launcher asks admission for a direct anthropic route and a fenced answer refuses the launch', async t => {
const { readFileSync } = fs;
const { createLauncher } = await import('../../cli/src/launcher.mjs');
const { initializeControl } = await import('../../processing-control/src/state.mjs');
const { fakeHarnesses, fixture, tmp, withoutHostCredentials } = await import('../../cli/tests/helpers.mjs');
// Ride all writes the organization's providers through its bus's plugins.set; this stand-in bus
// applies that write to the organization file the launcher reads.
const ride = async file => {
const dir = fs.mkdtempSync(join(tmpdir(), 'ride-fence-admin-')); t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
const call = async (verb, args = {}) => {
const doc = JSON.parse(readFileSync(file, 'utf8'));
if (verb === 'plugins') return { revision: 'r1', plugins: doc.plugins };
if (verb === 'proxy.accounts') return { accounts: [] };
if (verb === 'plugins.set') { assert.equal(args.revision, 'r1'); doc.plugins = { ...doc.plugins, ...args.plugins }; fs.writeFileSync(file, JSON.stringify(doc)); return { revision: 'r2' }; }
throw Object.assign(Error('unexpected verb'), { code: 'invalid-request' });
};
const admin = createProxyAdmin({ dataRoot: dir, configDir: dir, unit: { status: async () => ({}) }, buses: async () => [], fetch: async () => ({}),
riders: async () => [{ id: 'acme', fixture: false, cliproxy: false, changes: '', call }] });
assert.deepEqual((await admin.rideAll()).added, ['acme']);
};
const launchOf = async riding => {
const root = tmp(t);
const f = fixture(root, 'acme', doc => {
doc.plugins = { ...doc.plugins, harness: ['pi'] };
doc.launch.models['claude-opus-5-5'] = { provider: 'anthropic', model: 'claude-opus-5-5' };
doc.roles.coder.vars = { harness: 'pi', model: 'claude-opus-5-5', thinking: 'low' };
return doc;
});
if (riding) await ride(join(root, 'config', 'businesses', 'acme.json'));
initializeControl(f.dataRoot); withoutHostCredentials(f.env, { piKey: true });
const ops = [];
const host = { business: 'acme', beforeClose: () => {}, op: async x => {
ops.push(x.op);
if (x.op === 'identity') return { business: 'acme', role: 'pm' };
if (x.op === 'mayLaunch') return { allow: true };
if (x.op === 'modelAdmission') return { allow: false, code: 'proxy-uncertain' };
if (x.op === 'authorizeLaunch') throw Object.assign(Error('fixture authorization stop'), { code: 'fixture-policy' });
return {};
} };
const makeLoader = await fakeHarnesses(t, { pi: null }, write => write('model-provider', 'cliproxy', `export * from ${JSON.stringify(new URL('../../plugins/model-provider/cliproxy/index.mjs', import.meta.url).href)};`));
const system = { ...JSON.parse(readFileSync(f.config, 'utf8')), proxy: { port: 1, binary: '/fixture-unused' } };
const launcher = createLauncher({ host, system, env: f.env, makeLoader, bwrap: '/usr/bin/true', log: () => {} });
return { answer: await launcher.fromSession('fixture-cap', 'coder'), ops };
};
const before = await launchOf(false);
assert.equal(before.ops.includes('modelAdmission'), false, JSON.stringify(before));
assert.equal(before.ops.includes('mayLaunch'), true, 'the before launch reached the limit checks');
assert.notDeepEqual(before.answer, { ok: false, error: 'proxy-uncertain' });
const after = await launchOf(true);
assert.equal(after.ops.includes('modelAdmission'), true, JSON.stringify(after));
assert.deepEqual(after.answer, { ok: false, error: 'proxy-uncertain' });
});
+504
View File
@@ -0,0 +1,504 @@
// #1873 ride-default slice 1: Ride all adds the instance's model proxy (cliproxy) to the owner's
// organizations, skips and names the ones it must not change, and lists fixture organizations,
// which move to the owner's models only by a separate confirmed action.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { createHash } from 'node:crypto';
import { createProxyAdmin } from '../src/admin-control.mjs';
import { initFiles, receiptFile, appendReceipt, receiptsText, ownedText } from '../src/admin.mjs';
import { execFileSync } from 'node:child_process';
import { PIN } from '../src/common.mjs';
import { cliproxyRemoved, localRide, riddenOrgs, pickModel, fixtureMove, moveFixtureOrg, readRider, ownerModelsFrom } from '../src/ride.mjs';
import * as orgService from '../../organization/src/org-service.mjs';
import { orgUsesFixture } from '../../cli/src/dev-fixture.mjs';
const stopped = async () => ({ stopped: true, running: [] });
const row = (over = {}) => ({ key: 'claude-claude-opus-5-5', module: 'cliproxy', upstream: 'claude', provider: 'anthropic', model: 'claude-opus-5-5', label: 'Claude Opus 5.5', available: true, reason: null, harnesses: ['claude-code', 'pi'], ...over });
const glm = row({ key: 'zai-glm-5-3', upstream: 'zai', provider: 'zai', model: 'glm-5.3', label: 'GLM 5.3', harnesses: ['pi'] });
const committed = changes => JSON.stringify({ state: 'committed', changes }) + '\n';
const busError = code => Object.assign(new Error('bus text that must not leak'), { code });
// A fake organization bus: `plugins` answers the providers and revision; `proxy.accounts` answers
// or throws; `plugins.set` records the write.
function bus({ providers = ['fixture'], down = false, client = true, accounts = null, set = null } = {}) {
const calls = [];
const call = async (verb, args) => {
calls.push([verb, args]);
if (down) throw busError('no-bus-host');
if (verb === 'plugins') return { business: 'x', revision: 'rev-1', plugins: { 'model-provider': providers }, available: {} };
if (verb === 'proxy.accounts') { if (accounts) throw accounts; if (!client) throw busError('not-configured'); return { accounts: [] }; }
if (verb === 'plugins.set') { if (set) throw set; providers = args.plugins['model-provider']; return { revision: 'rev-2' }; }
throw new Error(`unexpected ${verb}`);
};
return { call, calls };
}
function admin(t, { riders, ownerModels, move, unitState } = {}) {
const root = fs.mkdtempSync(join(tmpdir(), 'rd-'));
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
fs.mkdirSync(configDir, { mode: 0o700 }); fs.mkdirSync(dataRoot, { mode: 0o700 });
const state = unitState ?? { installed: false, active: 'inactive', healthy: false };
const unit = { unit: 'mosaic-proxy-zz.service', status: async () => ({ unit: 'mosaic-proxy-zz.service', ...state }) };
const sha = text => createHash('sha256').update(text).digest('hex');
const pin = { ...PIN, archive: { ...PIN.archive, sha256: sha('a') }, binary: { sha256: sha('b') }, panel: { ...PIN.panel, sha256: sha('p') } };
const a = createProxyAdmin({ dataRoot, configDir, unit, buses: stopped, fetch: async () => ({}), now: () => new Date(0), pin,
...(riders ? { riders } : {}), ...(ownerModels ? { ownerModels } : {}), ...(move !== undefined ? { move } : {}) });
return { admin: a, configDir, dataRoot, pin, state };
}
const receipts = dataRoot => { try { return fs.readFileSync(receiptFile(dataRoot), 'utf8').trim().split('\n').filter(Boolean).map(JSON.parse); } catch { return []; } };
test('a change log shows cliproxy removed only when a committed write took it off', () => {
assert.equal(cliproxyRemoved(''), false);
assert.equal(cliproxyRemoved(committed([{ path: 'plugins.model-provider', old: ['fixture'], new: ['fixture', 'cliproxy'] }])), false);
assert.equal(cliproxyRemoved(committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }])), true);
assert.equal(cliproxyRemoved(committed([{ path: 'plugins', old: { 'model-provider': ['cliproxy'] }, new: { 'model-provider': ['fixture'] } }])), true);
assert.equal(cliproxyRemoved(JSON.stringify({ state: 'staged', changes: [{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }] }) + '\n'), false, 'a write that did not commit removed nothing');
assert.equal(cliproxyRemoved(committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }, { path: 'plugins.model-provider', old: [], new: ['cliproxy'] }]) ), true, 'a removal stays a removal once seen');
assert.equal(cliproxyRemoved('{not json\n'), null);
assert.equal(cliproxyRemoved(null), null);
});
test('the local rule names unreadable, removed, fixture, already and ready in that order', () => {
const removed = committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }]);
assert.equal(localRide({ fixture: undefined, cliproxy: false, changes: '' }), 'unreadable');
assert.equal(localRide({ fixture: false, cliproxy: undefined, changes: '' }), 'unreadable');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: null }), 'unreadable');
assert.equal(localRide({ fixture: true, cliproxy: false, changes: removed }), 'removed');
assert.equal(localRide({ fixture: true, cliproxy: false, changes: '' }), 'fixture');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: '' }), 'already');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: '' }), 'ready');
// Review round: an organization that uses cliproxy now is already riding, whatever its history.
assert.equal(localRide({ fixture: false, cliproxy: true, changes: removed }), 'already', 'removed once and added back');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: null }), 'already');
assert.equal(localRide({ fixture: true, cliproxy: true, changes: '' }), 'fixture');
// The proxy's receipts show it put cliproxy on the organization, and it lacks cliproxy now.
assert.equal(localRide({ fixture: false, cliproxy: false, changes: '', ridden: true }), 'removed');
assert.equal(localRide({ fixture: true, cliproxy: false, changes: '', ridden: true }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: '', ridden: true }), 'already');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: '', ridden: null }), 'unreadable');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: '', ridden: null }), 'already');
});
test('the proxy receipts name each organization ride all added, tried to add, moved or saw removed', () => {
const lines = records => records.map(r => JSON.stringify(r)).join('\n') + '\n';
const text = lines([{ op: 'ride-all', added: ['a', 'b'], skipped: [{ id: 'c', reason: 'bus-down' }], fixtures: ['d'] }, { op: 'ride-move', org: 'e', model: 'm' },
{ op: 'fetch', added: ['f'] }, { op: 'ride-intent', org: 'g' }, { op: 'ride-removed', org: 'h' }]);
assert.deepEqual([...riddenOrgs(text)].sort(), ['a', 'b', 'e', 'g', 'h']);
assert.deepEqual([...riddenOrgs('')], []);
assert.equal(riddenOrgs(null), null);
// Round 3 (P2a): a line that does not parse, or a ride record of the wrong shape, fails closed.
assert.equal(riddenOrgs(text + '{torn'), null, 'a torn line');
assert.equal(riddenOrgs(lines([{ op: 'ride-all', added: [7] }])), null);
assert.equal(riddenOrgs(lines([{ op: 'ride-all', added: 'a' }])), null);
assert.equal(riddenOrgs(lines([{ op: 'ride-intent' }])), null);
assert.equal(riddenOrgs(lines([{ op: 'ride-removed', org: 3 }])), null);
assert.equal(riddenOrgs('7\n'), null, 'a line that is not a record');
// Round 3 (P2b): an intent the bus then showed was not applied is cleared, and only that intent.
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-intent', org: 'g' }, { op: 'ride-not-added', org: 'g' }]))], []);
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-all', added: ['g'] }, { op: 'ride-intent', org: 'g' }, { op: 'ride-not-added', org: 'g' }]))], ['g'], 'an earlier add stays');
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-removed', org: 'g' }, { op: 'ride-intent', org: 'g' }, { op: 'ride-not-added', org: 'g' }]))], ['g'], 'an earlier removal stays');
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-not-added', org: 'g' }, { op: 'ride-intent', org: 'g' }]))], ['g'], 'a later intent stands');
});
test('a change log that shows cliproxy on the organization at any time, or a write to its providers it cannot read, counts as removed once cliproxy is gone', () => {
// Round 3 (P1 case b): added on the Settings page, then removed on the admin page, which writes no log entry.
const added = committed([{ path: 'plugins.model-provider', old: [], new: ['cliproxy'] }]);
assert.equal(localRide({ fixture: false, cliproxy: false, changes: added }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: added }), 'already');
assert.equal(localRide({ fixture: true, cliproxy: true, changes: added }), 'fixture', 'a fixture organization that lists cliproxy is still listed to move');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'plugins', old: null, new: { 'model-provider': ['cliproxy'] } }]) }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: '', old: null, new: { plugins: { 'model-provider': ['cliproxy'] } } }]) }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', oldPresent: true, newPresent: true }]) }), 'removed', 'a paths-only write to the providers');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'roles.chief.vars', oldPresent: true, newPresent: true }]) }), 'ready', 'a paths-only write elsewhere');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', old: ['fixture'], new: ['openai'] }]) }), 'ready');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: JSON.stringify({ state: 'aborted', changes: [{ path: 'plugins.model-provider', old: [], new: ['cliproxy'] }] }) + '\n' }), 'ready', 'a write that did not commit');
});
test('the reviewer probe: an organization created from the cliproxy preset and saved without it on its admin page is skipped as removed', async t => {
// P1 case a. Nothing in the change log: the preset made it, the admin page took it off. The
// admin page leaves a ride-removed receipt (proxy admin rideRemoved) before it saves.
const b = bus({ providers: [] });
const { admin: a, dataRoot } = admin(t, { riders: async () => [{ id: 'p', fixture: false, cliproxy: false, changes: '', call: b.call }] });
assert.equal(a.rideRemoved('p').op, 'ride-removed');
const r = await a.rideAll();
assert.deepEqual(r.added, []); assert.deepEqual(r.skipped, [{ id: 'p', reason: 'removed' }]);
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
assert.deepEqual(receipts(dataRoot).filter(x => x.op === 'ride-removed').map(x => x.org), ['p']);
assert.throws(() => a.rideRemoved('../x'), /proxy-org-invalid|invalid/);
});
test('the reviewer probe: an organization added on the Settings page and removed on its admin page is skipped as removed', async t => {
// P1 case b, with no ride-removed receipt at all: the change log's add is enough.
const b = bus({ providers: [] });
const log = committed([{ path: 'plugins.model-provider', old: [], new: ['cliproxy'] }]);
const { admin: a } = admin(t, { riders: async () => [{ id: 's', fixture: false, cliproxy: false, changes: log, call: b.call }] });
const r = await a.rideAll();
assert.deepEqual(r.added, []); assert.deepEqual(r.skipped, [{ id: 's', reason: 'removed' }]);
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
});
test('each add leaves its intent receipt before plugins.set, and an add whose outcome is unknown stays recorded', async t => {
// P2b. The bus reads the receipts at the moment of the write.
let seen = null, dataRootOf = null;
const order = [];
const watching = id => { const b = bus({ providers: [] }); const call = async (verb, args) => { if (verb === 'plugins.set') { order.push(id); seen = receipts(dataRootOf()).map(r => `${r.op}:${r.org ?? ''}`); } return b.call(verb, args); }; return { ...b, call }; };
const one = watching('one'), two = watching('two');
const f = admin(t, { riders: async () => [{ id: 'one', fixture: false, cliproxy: false, changes: '', call: one.call }, { id: 'two', fixture: false, cliproxy: false, changes: '', call: two.call }] });
dataRootOf = () => f.dataRoot;
await f.admin.rideAll();
assert.deepEqual(order, ['one', 'two']);
assert.deepEqual(seen, ['ride-intent:one', 'ride-intent:two'], 'the first add is on record before the second starts');
// Probe C: plugins.set commits, then the call times out. The bus shows cliproxy, so the intent stands.
let providers = [];
const timeout = { calls: [], call: async (verb, args) => {
if (verb === 'plugins') return { revision: 'r1', plugins: { 'model-provider': providers } };
if (verb === 'proxy.accounts') return { accounts: [] };
if (verb === 'plugins.set') { providers = args.plugins['model-provider']; throw busError('timeout'); }
} };
let cp = false;
const c = admin(t, { riders: async () => [{ id: 't', fixture: false, cliproxy: cp, changes: '', call: timeout.call }] });
const first = await c.admin.rideAll();
assert.deepEqual(first.skipped, [{ id: 't', reason: 'timeout' }]);
assert.deepEqual(receipts(c.dataRoot).filter(r => r.org === 't').map(r => r.op), ['ride-intent']);
providers = []; // the owner took it off
assert.deepEqual((await c.admin.rideAll()).skipped, [{ id: 't', reason: 'removed' }]);
// A refusal the bus shows was not applied clears the intent, so the organization can ride later.
const refusedBus = bus({ providers: [], set: busError('revision-conflict') });
const d = admin(t, { riders: async () => [{ id: 'q', fixture: false, cliproxy: false, changes: '', call: refusedBus.call }] });
assert.deepEqual((await d.admin.rideAll()).skipped, [{ id: 'q', reason: 'revision-conflict' }]);
assert.deepEqual(receipts(d.dataRoot).filter(r => r.org === 'q').map(r => r.op), ['ride-intent', 'ride-not-added']);
assert.deepEqual((await d.admin.status()).ride, [{ id: 'q', state: 'ready' }]);
// A bus that does not answer the re-read leaves the intent: the add may have happened.
let gone = false;
const lost = { call: async (verb, args) => { if (gone) throw busError('no-bus-host'); if (verb === 'plugins') return { revision: 'r1', plugins: { 'model-provider': [] } }; if (verb === 'proxy.accounts') return { accounts: [] }; if (verb === 'plugins.set') { gone = true; throw busError('timeout'); } } };
const e = admin(t, { riders: async () => [{ id: 'l', fixture: false, cliproxy: false, changes: '', call: lost.call }] });
await e.admin.rideAll();
assert.deepEqual(receipts(e.dataRoot).filter(r => r.org === 'l').map(r => r.op), ['ride-intent']);
});
test('a removal saved while Ride all works on earlier organizations is read before the later add', async t => {
// Re-check 3, P3-1: the run's first read of the receipts showed nothing for 'late'. While the run
// reads 'first', the owner takes cliproxy off 'late' on its admin page (a ride-removed receipt).
let a = null;
const first = bus({ providers: [] }), late = bus({ providers: [] });
const firstCall = async (verb, args) => { if (verb === 'plugins') a.rideRemoved('late'); return first.call(verb, args); };
const f = admin(t, { riders: async () => [{ id: 'first', fixture: false, cliproxy: false, changes: '', call: firstCall }, { id: 'late', fixture: false, cliproxy: false, changes: '', call: late.call }] });
a = f.admin;
const r = await a.rideAll();
assert.deepEqual(r.added, ['first']); assert.deepEqual(r.skipped, [{ id: 'late', reason: 'removed' }]);
assert.equal(late.calls.some(([v]) => v === 'plugins.set'), false);
assert.deepEqual(receipts(f.dataRoot).filter(x => x.org === 'late').map(x => x.op), ['ride-removed']);
// Receipts that turn unreadable during the run skip the later add as unreadable.
const g1 = bus({ providers: [] }), g2 = bus({ providers: [] });
let g = null;
const tear = async (verb, args) => { if (verb === 'plugins') { appendReceipt(g.dataRoot, { op: 'fetch' }); fs.appendFileSync(receiptFile(g.dataRoot), '{torn\n'); } return g1.call(verb, args); };
g = admin(t, { riders: async () => [{ id: 'one', fixture: false, cliproxy: false, changes: '', call: tear }, { id: 'two', fixture: false, cliproxy: false, changes: '', call: g2.call }] });
const s = await g.admin.rideAll();
assert.deepEqual(s.skipped, [{ id: 'one', reason: 'unreadable' }, { id: 'two', reason: 'unreadable' }]);
assert.equal(g2.calls.some(([v]) => v === 'plugins.set'), false);
});
test('an intent receipt that cannot be written stops that add before plugins.set', async t => {
const b = bus({ providers: [] });
const f = admin(t, { riders: async () => [{ id: 'w', fixture: false, cliproxy: false, changes: '', call: b.call }] });
appendReceipt(f.dataRoot, { op: 'fetch' });
fs.chmodSync(receiptFile(f.dataRoot), 0o400); // readable by its owner only, not writable
const r = await f.admin.rideAll();
assert.deepEqual(r.skipped, [{ id: 'w', reason: 'not-recorded' }]);
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
});
test('receipts that are torn, a symlink, not the owner\'s or open to others are unreadable, and every organization without cliproxy is skipped', async t => {
// P2a and P3 (probes D and E).
const b = bus({ providers: [] });
const f = admin(t, { riders: async () => [{ id: 'z', fixture: false, cliproxy: false, changes: '', call: b.call }, { id: 'y', fixture: false, cliproxy: true, changes: '', call: b.call }] });
const file = receiptFile(f.dataRoot);
appendReceipt(f.dataRoot, { op: 'fetch' });
fs.appendFileSync(file, '{"op":"ride-all","added":["z"]');
let r = await f.admin.rideAll();
assert.deepEqual(r.skipped, [{ id: 'z', reason: 'unreadable' }], 'torn'); assert.deepEqual(r.already, ['y']);
fs.rmSync(file); fs.writeFileSync(join(f.dataRoot, 'state', 'empty'), '', { mode: 0o600 });
fs.symlinkSync(join(f.dataRoot, 'state', 'empty'), file);
assert.deepEqual((await f.admin.rideAll()).skipped, [{ id: 'z', reason: 'unreadable' }], 'symlink');
assert.equal(fs.lstatSync(file).isSymbolicLink(), true);
fs.rmSync(file); fs.writeFileSync(file, '', { mode: 0o600 }); fs.chmodSync(file, 0o640);
assert.deepEqual((await f.admin.rideAll()).skipped, [{ id: 'z', reason: 'unreadable' }], 'group-readable');
fs.rmSync(file); fs.mkdirSync(file);
assert.deepEqual((await f.admin.rideAll()).skipped, [{ id: 'z', reason: 'unreadable' }], 'not a file');
fs.rmSync(file, { recursive: true });
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
assert.deepEqual((await f.admin.rideAll()).added, ['z'], 'no receipt file is no history');
});
test('the receipts are read only when the Console\'s own user owns them', t => {
const f = admin(t);
appendReceipt(f.dataRoot, { op: 'ride-removed', org: 'p' });
assert.match(receiptsText(f.dataRoot), /"ride-removed"/);
assert.equal(receiptsText(f.dataRoot, { uid: process.getuid() + 1 }), null, 'another user\'s file');
});
test('a FIFO in place of the receipts is unreadable and never blocks the read', t => {
const f = admin(t);
fs.mkdirSync(join(f.dataRoot, 'state'), { mode: 0o700 });
execFileSync('mkfifo', ['-m', '600', receiptFile(f.dataRoot)]);
assert.equal(receiptsText(f.dataRoot), null);
});
test('the change log read takes the writer\'s rule: group readable is fine, group writable, a symlink or a missing file is not', t => {
const dir = fs.mkdtempSync(join(tmpdir(), 'rdo-')); t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
const file = join(dir, 'changes.jsonl'); fs.writeFileSync(file, 'x\n', { mode: 0o600 }); fs.chmodSync(file, 0o640);
assert.equal(ownedText(file, { mask: 0o022 }), 'x\n');
fs.chmodSync(file, 0o660);
assert.throws(() => ownedText(file, { mask: 0o022 }), { code: 'proxy-file-refused' });
fs.chmodSync(file, 0o600); fs.symlinkSync(file, join(dir, 'link'));
assert.throws(() => ownedText(join(dir, 'link'), { mask: 0o022 }), { code: 'ELOOP' });
assert.throws(() => ownedText(join(dir, 'gone'), { mask: 0o022 }), { code: 'ENOENT' });
// readRider, as the Console wires it: a refused log is unreadable, a missing one is empty.
const doc = { plugins: { 'model-provider': [] } };
fs.chmodSync(file, 0o660);
assert.equal(readRider({ id: 'a', read: () => doc, readLog: () => ownedText(file, { mask: 0o022 }), isFixture: () => false }).changes, null);
assert.equal(readRider({ id: 'a', read: () => doc, readLog: () => ownedText(join(dir, 'gone'), { mask: 0o022 }), isFixture: () => false }).changes, '');
});
test('a fixture organization that uses cliproxy now, with a removal in its log, is removed, not movable', () => {
const log = committed([{ path: 'plugins.model-provider', old: ['fixture', 'cliproxy'], new: ['fixture'] }]) + committed([{ path: 'plugins.model-provider', old: ['fixture'], new: ['fixture', 'cliproxy'] }]);
assert.equal(localRide({ fixture: true, cliproxy: true, changes: log }), 'removed');
assert.equal(localRide({ fixture: true, cliproxy: true, changes: '' }), 'fixture');
});
test('an organization ride all once added and its owner then saved without cliproxy is skipped as removed', async t => {
// The organization's file as the Console reads it. The organization admin page saves a whole
// document and writes no change-log entry, so the log stays empty after the owner's removal.
let cliproxy = false;
const b = bus({ providers: [] });
const { admin: a, dataRoot } = admin(t, { riders: async () => [{ id: 'a', fixture: false, cliproxy, changes: '', call: b.call }] });
assert.deepEqual((await a.rideAll()).added, ['a']);
cliproxy = true;
assert.deepEqual((await a.rideAll()).already, ['a']);
cliproxy = false; // the owner saved the organization without cliproxy on its admin page
const second = await a.rideAll();
assert.deepEqual(second.skipped, [{ id: 'a', reason: 'removed' }], JSON.stringify(second));
assert.equal(b.calls.filter(([verb]) => verb === 'plugins.set').length, 1, 'no second write');
assert.deepEqual((await a.status()).ride, [{ id: 'a', state: 'removed' }]);
// A fixture organization the proxy once moved, and its owner then put back on stand-in models, is not moved again.
const moved = { id: 'f', fixture: true, cliproxy: false, changes: '', call: bus({ down: true }).call };
const m = admin(t, { riders: async () => [moved], ownerModels: async () => ({ proxy: true, riding: true, models: [row()] }), move: async () => ({ moved: true, model: row().key }) });
appendReceipt(m.dataRoot, { op: 'ride-move', org: 'f', model: row().key });
assert.deepEqual(await m.admin.rideMove({ org: 'f' }), { org: 'f', moved: false, reason: 'removed' });
// Receipts that cannot be read name every organization without cliproxy unreadable.
fs.chmodSync(receiptFile(dataRoot), 0o200);
assert.deepEqual((await a.rideAll()).skipped, [{ id: 'a', reason: 'unreadable' }]);
});
test('the owner model is a usable catalogue row that serves every harness, claude first', () => {
assert.equal(pickModel([glm, row()]).key, 'claude-claude-opus-5-5');
assert.equal(pickModel([glm]).key, 'zai-glm-5-3');
assert.equal(pickModel([glm, row()], ['claude-code']).key, 'claude-claude-opus-5-5');
assert.equal(pickModel([glm], ['claude-code']), null);
assert.equal(pickModel([row({ available: false }), row({ reason: 'unverified' }), row({ module: 'fixture' })]), null, 'a model the catalogue does not offer is never picked');
assert.equal(pickModel(null), null);
});
test('ride all adds cliproxy through plugins.set and skips and names each organization it must not change', async t => {
const ready = bus({ providers: [] }), noClient = bus({ providers: [], client: false }), down = bus({ down: true }), checkFails = bus({ providers: [], accounts: busError('proxy-down') });
const refused = bus({ providers: [], set: busError('revision-conflict') }), alreadyBus = bus({ providers: ['cliproxy'] }), removedBus = bus({ providers: [] }), fixtureBus = bus({ down: true });
const unreadable = bus({ providers: [] }), raced = bus({ providers: ['cliproxy'] });
const riders = async () => [
{ id: 'ready', fixture: false, cliproxy: false, changes: '', call: ready.call },
{ id: 'removed', fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }]), call: removedBus.call },
{ id: 'down', fixture: false, cliproxy: false, changes: '', call: down.call },
{ id: 'noclient', fixture: false, cliproxy: false, changes: '', call: noClient.call },
{ id: 'checkfails', fixture: false, cliproxy: false, changes: '', call: checkFails.call },
{ id: 'refused', fixture: false, cliproxy: false, changes: '', call: refused.call },
{ id: 'already', fixture: false, cliproxy: true, changes: '', call: alreadyBus.call },
{ id: 'raced', fixture: false, cliproxy: false, changes: '', call: raced.call },
{ id: 'unreadable', fixture: undefined, cliproxy: undefined, changes: '', call: unreadable.call },
{ id: 'stand-in', fixture: true, cliproxy: false, changes: '', call: fixtureBus.call, status: async () => ({ pid: null }) },
];
const { admin: a, dataRoot } = admin(t, { riders });
const result = await a.rideAll();
assert.deepEqual(result.added, ['ready']);
assert.deepEqual(result.already, ['already', 'raced']);
assert.deepEqual(result.skipped, [
{ id: 'removed', reason: 'removed' }, { id: 'down', reason: 'bus-down' }, { id: 'noclient', reason: 'no-proxy-client' },
{ id: 'checkfails', reason: 'proxy-check-failed' }, { id: 'refused', reason: 'revision-conflict' }, { id: 'unreadable', reason: 'unreadable' },
]);
assert.deepEqual(result.fixtures, [{ id: 'stand-in', running: false }]);
assert.deepEqual(ready.calls.find(([v]) => v === 'plugins.set'), ['plugins.set', { revision: 'rev-1', plugins: { 'model-provider': ['cliproxy'] } }]);
for (const [name, b] of Object.entries({ removedBus, down, noClient, checkFails, alreadyBus, raced, unreadable, fixtureBus }))
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false, `${name} gets no write`);
assert.equal(JSON.stringify(result).includes('must not leak'), false);
const last = receipts(dataRoot).at(-1);
assert.equal(last.op, 'ride-all'); assert.deepEqual(last.added, ['ready']); assert.deepEqual(last.fixtures, ['stand-in']);
});
test('ride all keeps the providers an organization already has', async t => {
const b = bus({ providers: ['openai'] });
const { admin: a } = admin(t, { riders: async () => [{ id: 'o', fixture: false, cliproxy: false, changes: '', call: b.call }] });
assert.deepEqual((await a.rideAll()).added, ['o']);
assert.deepEqual(b.calls.find(([v]) => v === 'plugins.set')[1].plugins, { 'model-provider': ['openai', 'cliproxy'] });
});
test('status names ride all after accounts while an organization can still ride', async t => {
let list = [{ id: 'o', fixture: false, cliproxy: false, changes: '', call: bus().call }];
const f = admin(t, { riders: async () => list, unitState: { installed: true, active: 'active', healthy: true, pid: 3 } });
const binDir = join(f.dataRoot, 'opt', 'cliproxyapi', PIN.version);
fs.mkdirSync(join(binDir, 'static'), { recursive: true });
fs.writeFileSync(join(binDir, 'cli-proxy-api'), 'b'); fs.writeFileSync(join(binDir, 'static', 'management.html'), 'p');
const files = initFiles(f.configDir, f.dataRoot);
fs.mkdirSync(join(f.configDir, 'secrets'), { mode: 0o700 }); fs.writeFileSync(files.key, 'fixture', { mode: 0o600 });
fs.mkdirSync(files.proxyDir, { mode: 0o700 });
fs.writeFileSync(files.settings, JSON.stringify({ binary: join(binDir, 'cli-proxy-api'), port: 18432 }), { mode: 0o600 });
let status = await f.admin.status();
assert.deepEqual(status.next, ['accounts', 'ride-all']);
assert.deepEqual(status.ride, [{ id: 'o', state: 'ready' }]);
list = [{ id: 'o', fixture: true, cliproxy: false, changes: '', call: bus().call }];
assert.deepEqual((await f.admin.status()).next, ['accounts', 'ride-all'], 'a fixture organization can still be moved');
list = [{ id: 'o', fixture: false, cliproxy: true, changes: '', call: bus().call }];
status = await f.admin.status();
assert.deepEqual(status.next, ['accounts']);
list = [{ id: 'o', fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }]), call: bus().call }];
assert.deepEqual((await f.admin.status()).next, ['accounts'], 'a removed organization is not a reason to ride');
f.state.healthy = false;
list = [{ id: 'o', fixture: false, cliproxy: false, changes: '', call: bus().call }];
assert.deepEqual((await f.admin.status()).next, ['unit-restart'], 'never before the proxy answers');
});
test('a fixture organization moves only when stopped, with a proxy, a riding bus and a move seam', async t => {
const owner = { proxy: true, riding: true, models: [row()] };
const moves = [];
const move = async (id, models, principal) => { moves.push({ id, models, principal }); return { moved: true, model: models[0].key }; };
let stoppedBus = bus({ down: true }), runningBus = bus();
// Round 3 (P2c): stopped is the organization admin page's test, a bus status with no process id.
const stopped = async () => ({ healthy: false, pid: null }), running = async () => ({ healthy: true, pid: 4242 });
const riders = async () => [
{ id: 'stand-in', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call, status: stopped },
{ id: 'live', fixture: true, cliproxy: false, changes: '', call: runningBus.call, status: running },
{ id: 'busy', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call, status: async () => ({ healthy: false, pid: 4343 }) },
{ id: 'unproven', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call, status: async () => { throw busError('stale-host'); } },
{ id: 'no-status', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call },
{ id: 'real', fixture: false, cliproxy: false, changes: '', call: stoppedBus.call, status: stopped },
];
let ownerNow = owner;
const f = admin(t, { riders, ownerModels: async () => ownerNow, move });
const principal = { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner' };
assert.deepEqual(await f.admin.rideMove({ org: 'nope', principal }), { org: 'nope', moved: false, reason: 'unknown' });
assert.deepEqual(await f.admin.rideMove({ org: 'real', principal }), { org: 'real', moved: false, reason: 'ready' });
assert.deepEqual(await f.admin.rideMove({ org: 'live', principal }), { org: 'live', moved: false, reason: 'bus-running' });
// A slow or busy bus that does not answer, a status that cannot be read, or no status at all is running.
for (const org of ['busy', 'unproven', 'no-status']) assert.deepEqual(await f.admin.rideMove({ org, principal }), { org, moved: false, reason: 'bus-running' }, org);
const listed = await f.admin.rideAll();
assert.deepEqual(listed.fixtures, [{ id: 'stand-in', running: false }, { id: 'live', running: true }, { id: 'busy', running: true }, { id: 'unproven', running: true }, { id: 'no-status', running: true }]);
ownerNow = { ...owner, proxy: false };
assert.deepEqual(await f.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'no-proxy' });
ownerNow = { ...owner, riding: false };
assert.deepEqual(await f.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'no-riding-bus' });
assert.equal(moves.length, 0);
ownerNow = owner;
const done = await f.admin.rideMove({ org: 'stand-in', principal });
assert.equal(done.moved, true); assert.equal(done.model, 'claude-claude-opus-5-5');
assert.deepEqual(moves, [{ id: 'stand-in', models: [row()], principal }]);
const last = receipts(f.dataRoot).at(-1);
assert.deepEqual({ op: last.op, org: last.org, model: last.model }, { op: 'ride-move', org: 'stand-in', model: 'claude-claude-opus-5-5' });
const none = admin(t, { riders, ownerModels: async () => owner, move: null });
assert.deepEqual(await none.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'not-available' });
const throws = admin(t, { riders, ownerModels: async () => owner, move: async () => { throw Object.assign(new Error('raw text'), { code: 'revision-conflict' }); } });
assert.deepEqual(await throws.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'revision-conflict' });
});
test('the fixture move rewrites the model provider, the model entry and every role that used it', async () => {
const doc = await orgService.templateRender('alpha', { fixture: 'local' });
Object.assign(doc.roles.assistant.vars, { 'fallback.harness': 'pi', 'fallback.model': 'fixture-deterministic', 'fallback.thinking': 'off' });
doc.projects.work.agents = { helper: { definition: 'coder', vars: { harness: 'pi', model: 'fixture-deterministic', thinking: 'off' } } };
assert.deepEqual(await orgService.validateOrg(doc), { ok: true, errors: [] });
assert.equal(orgUsesFixture(doc), true);
const { doc: next, model } = fixtureMove(doc, [glm, row()]);
assert.equal(model.key, 'claude-claude-opus-5-5', 'the fixture assistant runs pi; of the models that serve pi, claude comes first');
assert.equal(orgUsesFixture(next), false);
assert.deepEqual(next.plugins['model-provider'], ['cliproxy']);
assert.deepEqual(next.launch.models, { 'claude-claude-opus-5-5': { provider: 'anthropic', model: 'claude-opus-5-5', module: 'cliproxy', upstream: 'claude' } });
assert.equal(next.roles.assistant.vars.model, 'claude-claude-opus-5-5');
assert.equal(next.roles.assistant.vars['fallback.model'], 'claude-claude-opus-5-5');
assert.equal(next.roles.assistant.vars.harness, 'pi', 'the harness is left as it was');
assert.equal(next.projects.work.agents.helper.vars.model, 'claude-claude-opus-5-5', 'a project\'s own agent moves too');
assert.deepEqual(await orgService.validateOrg(next), { ok: true, errors: [] });
const zai = fixtureMove(doc, [glm]);
assert.equal(zai.model.key, 'zai-glm-5-3');
assert.deepEqual(zai.doc.launch.models, { 'zai-glm-5-3': { provider: 'zai', model: 'glm-5.3', module: 'cliproxy', upstream: 'zai' } });
assert.deepEqual(await orgService.validateOrg(zai.doc), { ok: true, errors: [] });
assert.equal(doc.plugins['model-provider'][0], 'fixture', 'the input is not changed');
assert.deepEqual(fixtureMove(doc, [row({ harnesses: ['claude-code'] })]), { reason: 'no-model' }, 'a model that cannot serve the harness is not used');
assert.deepEqual(fixtureMove(doc, [row({ available: false, harnesses: ['pi'] })]), { reason: 'no-model' }, 'a model the catalogue does not offer is not used');
});
test('the fixture move writes through the organization service as the owner, and only at the revision read', async () => {
const root = fs.mkdtempSync(join(tmpdir(), 'rd-svc-'));
try {
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
fs.mkdirSync(configDir, { mode: 0o700 }); fs.mkdirSync(dataRoot, { mode: 0o700 });
const ctx = { configDir, dataRoot, instance: 'test', principal: { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner' } };
await orgService.createOrg(ctx, 'alpha', await orgService.templateRender('alpha', { fixture: 'local' }));
const stranger = { ...ctx, principal: { provider: 'sso', iss: 'https://idp.invalid', sub: 'someone' } };
await assert.rejects(moveFixtureOrg({ service: orgService, ctx: stranger, id: 'alpha', models: [row()] }));
assert.equal(orgUsesFixture((await orgService.showOrg(ctx, 'alpha')).doc), true, 'a stranger moved nothing');
assert.deepEqual(await moveFixtureOrg({ service: orgService, ctx, id: 'alpha', models: [row({ harnesses: ['claude-code'] })] }), { moved: false, reason: 'no-model' });
// A moved document the service does not accept is not written.
const refusing = { ...orgService, validateOrg: async () => ({ ok: false, errors: [{ path: '$', message: 'no' }] }) };
assert.deepEqual(await moveFixtureOrg({ service: refusing, ctx, id: 'alpha', models: [row()] }), { moved: false, reason: 'invalid' });
assert.equal(orgUsesFixture((await orgService.showOrg(ctx, 'alpha')).doc), true, 'an invalid move wrote nothing');
// A write between the read and the update loses: the service refuses the stale revision.
const racing = { ...orgService, validateOrg: async d => { const now = await orgService.showOrg(ctx, 'alpha'); await orgService.updateOrg(ctx, 'alpha', now.doc, { ifRevision: now.revision }); return orgService.validateOrg(d); } };
await assert.rejects(moveFixtureOrg({ service: racing, ctx, id: 'alpha', models: [row()] }), { code: 'revision-conflict' });
assert.equal(orgUsesFixture((await orgService.showOrg(ctx, 'alpha')).doc), true);
assert.deepEqual(await moveFixtureOrg({ service: orgService, ctx, id: 'alpha', models: [row()] }), { moved: true, model: 'claude-claude-opus-5-5' });
const after = (await orgService.showOrg(ctx, 'alpha')).doc;
assert.equal(orgUsesFixture(after), false);
assert.deepEqual(after.plugins['model-provider'], ['cliproxy']);
assert.equal(after.roles.assistant.vars.model, 'claude-claude-opus-5-5');
assert.deepEqual(after.launch.models['claude-claude-opus-5-5'], { provider: 'anthropic', model: 'claude-opus-5-5', module: 'cliproxy', upstream: 'claude' });
} finally { fs.rmSync(root, { recursive: true, force: true }); }
});
test('an organization is read from its file and change log; a missing log is empty and any other failure unreadable', () => {
const enoent = () => { throw Object.assign(new Error('missing'), { code: 'ENOENT' }); };
const eacces = () => { throw Object.assign(new Error('denied'), { code: 'EACCES' }); };
const doc = providers => ({ plugins: { 'model-provider': providers } });
assert.deepEqual(readRider({ id: 'a', read: () => doc(['cliproxy']), readLog: () => 'log', isFixture: () => false }), { id: 'a', fixture: false, cliproxy: true, changes: 'log' });
assert.deepEqual(readRider({ id: 'b', read: () => doc(['fixture']), readLog: enoent, isFixture: () => true }), { id: 'b', fixture: true, cliproxy: false, changes: '' });
assert.deepEqual(readRider({ id: 'c', read: () => ({}), readLog: eacces, isFixture: () => false }), { id: 'c', fixture: false, cliproxy: false, changes: null });
const unread = readRider({ id: 'd', read: () => { throw new Error('bad json'); }, readLog: () => '', isFixture: () => true });
assert.deepEqual(unread, { id: 'd', fixture: undefined, cliproxy: undefined, changes: '' });
assert.equal(localRide(unread), 'unreadable');
assert.equal(localRide(readRider({ id: 'c', read: () => ({}), readLog: eacces, isFixture: () => false })), 'unreadable');
// The real fixture test decides the fixture field.
assert.equal(readRider({ id: 'e', read: () => doc(['fixture']), readLog: () => '', isFixture: orgUsesFixture }).fixture, true);
});
test('the owner models come only from riding buses that answer a ready catalogue, cliproxy rows once each', async () => {
const asked = [];
const rider = (id, cliproxy, answer) => ({ id, cliproxy, call: async verb => { asked.push([id, verb]); if (answer instanceof Error) throw answer; return answer; } });
const ready = models => ({ catalogue: { status: 'ready', models } });
assert.deepEqual(await ownerModelsFrom({ proxy: false, riders: [rider('a', true, ready([row()]))] }), { proxy: false, riding: false, models: [] });
assert.deepEqual(asked, [], 'no proxy asks no bus');
const fixtureRow = row({ key: 'fixture-deterministic', module: 'fixture' });
const answer = await ownerModelsFrom({ proxy: true, riders: [
rider('a', true, ready([row(), fixtureRow])), rider('b', true, ready([row({ label: 'later copy' }), glm])), rider('c', false, ready([row({ key: 'not-riding' })])),
rider('d', true, { catalogue: { status: 'unavailable', models: [row({ key: 'fenced' })] } }), rider('e', true, busError('no-bus-host')),
] });
assert.deepEqual(answer, { proxy: true, riding: true, models: [row(), glm] });
assert.deepEqual(asked.map(([id]) => id).sort(), ['a', 'b', 'd', 'e'], 'only organizations that list cliproxy are asked');
assert.deepEqual(await ownerModelsFrom({ proxy: true, riders: [rider('d', true, { catalogue: { status: 'unavailable', models: [] } }), rider('e', true, busError('no-bus-host'))] }), { proxy: true, riding: false, models: [] });
// A hung bus does not hold the others back: they are asked together.
let release; const hung = { id: 'h', cliproxy: true, call: () => new Promise(r => { release = r; }) };
const pending = ownerModelsFrom({ proxy: true, riders: [hung, rider('a', true, ready([row()]))] });
await new Promise(r => setImmediate(r));
assert.equal(asked.filter(([id]) => id === 'a').length, 2, 'the second bus was asked while the first hung');
release(null); assert.deepEqual((await pending).models, [row()]);
// Review round: a key one bus lists as unavailable and another as usable keeps the usable row.
const stale = row({ available: false, reason: 'proxy-down', label: 'stale' });
assert.deepEqual((await ownerModelsFrom({ proxy: true, riders: [rider('s', true, ready([stale])), rider('a', true, ready([row()]))] })).models, [row()]);
assert.deepEqual((await ownerModelsFrom({ proxy: true, riders: [rider('a', true, ready([row()])), rider('s', true, ready([stale]))] })).models, [row()]);
});
+8
View File
@@ -684,3 +684,11 @@ After the pinned window, use an ordinary new decision.
Policy has no effect executor. Per the Lead ruling, its in and existing out
levels work, while near refuses `policy-reverse-unavailable` and directs the
owner to choose in or out. Policy near and its reverse wait for that executor.
### Pack hires and rights (ruling 2026-11-14, #1873)
`src/org-rights.mjs` maps `pack.hire.console` to `org.hire`: hiring a starter
pack's proposed agents is a hire, so a member with that right hires the
unflagged proposals and the rest wait for the owner (invariant 7). The read
`instanceSettings` returns each instance's `hireDecision`, which the bus's
`instances` read uses to name the pack an agent came from.
@@ -9,6 +9,7 @@ import { join } from "node:path";
import { refuse } from "./errors.mjs";
import { checkDefinitions } from "./definitions.mjs";
import { loadRole } from "./role.mjs";
import { SYSTEM_ONLY_REFUSAL, systemOnly } from "./vocabulary.mjs";
import { checkVars, mergeVars, REGISTRY } from "./vars.mjs";
import { deepFreeze, isPlainObject, readJsonFile, rejectUnknownKeys, requireDistinctList, requireId, requireObject } from "./util.mjs";
@@ -27,6 +28,8 @@ export function rootAgentsPath(configDir) {
function definitionOf(name, at, rolesDir, cache, definitions = {}) {
if (typeof name === "string" && name.startsWith("org:") && Object.hasOwn(definitions,name)) return definitions[name];
requireId(name, `${at}.definition`);
// #1873 triage-fence: no root or project agent, and so no copy of one, names a system-only template.
if (systemOnly(name)) refuse(`${SYSTEM_ONLY_REFUSAL}: ${at}.definition names ${name}, a template no organization may hold`);
if (!cache.has(name)) {
// A role refusal names host paths; this message travels to the Console, so it names none.
try { cache.set(name, loadRole(rolesDir, name)); }
@@ -15,6 +15,7 @@ import { OrganizationError } from "./organization.mjs";
import {
diffDefinition, entryFromTemplate, instancesNaming, readTemplate, templateHashes, checkDefinitionName, ORG_PREFIX,
} from "./definitions.mjs";
import { SYSTEM_ONLY_REFUSAL, systemOnly } from "./vocabulary.mjs";
// The verb names the policy table maps, following R1's hire.resolve.console.
export const DEFINITION_VERBS = Object.freeze({
@@ -64,6 +65,8 @@ export function definitionVerbs({ writer, rolesDir, assertClean }) {
// Copies a template into definitions with from set to its name and current hash.
function importTemplate(id, { revision, template, as = template }, caller) {
authorize(caller, "import");
// #1873 triage-fence: no organization imports a system-only template.
if (systemOnly(template)) fail(SYSTEM_ONLY_REFUSAL);
checkDefinitionName(as, "definition name");
const source = readTemplate(rolesDir, template);
const result = writer.setDefinition(id, as, (current) => {
@@ -125,5 +128,5 @@ export function definitionVerbs({ writer, rolesDir, assertClean }) {
return { organization: id, revision, ...diffDefinition(document, name, rolesDir) };
}
return { import: importTemplate, edit, invent, remove, list, show, diff, templates: () => templateHashes(rolesDir) };
return { import: importTemplate, edit, invent, remove, list, show, diff, templates: () => templateHashes(rolesDir).filter(({ template }) => !systemOnly(template)) };
}
+3 -1
View File
@@ -23,7 +23,7 @@ import { createHash } from "node:crypto";
import { refuse } from "./errors.mjs";
import { buildRegistry, checkComposition } from "./composition.mjs";
import { validateRoleDocument } from "./role.mjs";
import { ID_PATTERN } from "./vocabulary.mjs";
import { ID_PATTERN, SYSTEM_ONLY_REFUSAL, systemOnly } from "./vocabulary.mjs";
import { canonicalJson, deepFreeze } from "./util.mjs";
export const ORG_PREFIX = "org:";
@@ -88,6 +88,8 @@ export function checkDefinition(name, entry, { assertClean = NO_STORE, where = "
keysOnly(entry.from, FROM_KEYS, `${at}.from`);
if (typeof entry.from.template !== "string" || !ID_PATTERN.test(entry.from.template)) refuse(`${at}.from.template must be a template name matching ${ID_PATTERN}`);
if (typeof entry.from.sha256 !== "string" || !HEX64.test(entry.from.sha256)) refuse(`${at}.from.sha256 must be 64 lowercase hex characters`);
// #1873 triage-fence: no organization definition copies a system-only template.
if (systemOnly(entry.from.template)) refuse(`${SYSTEM_ONLY_REFUSAL}: ${at}.from.template names ${entry.from.template}, a template no organization may hold`);
}
if (!plain(entry.role)) refuse(`${at}.role must be a JSON object`);
keysOnly(entry.role, ROLE_KEYS, `${at}.role`);
+5 -2
View File
@@ -8,7 +8,7 @@ import { compositionOf, entryFromTemplate, readTemplate, templateHashes } from '
import { readRootAgentsFile, changeRootAgent } from './agent-levels-write.mjs';
import { validateBusinessDocument } from './organization-config.mjs';
import { canonicalJson, isPlainObject, readJsonFile } from './util.mjs';
import { ID_PATTERN, NETWORKS } from './vocabulary.mjs';
import { ID_PATTERN, NETWORKS, SYSTEM_ONLY_REFUSAL, systemOnly } from './vocabulary.mjs';
import { OrganizationError } from './organization.mjs';
import { resolveInstance } from './resolve.mjs';
import { checkRoutes } from './launch-settings.mjs';
@@ -204,6 +204,8 @@ export function hireDecisions({ writer, rolesDir, configDir, dataRoot, assertCle
if ('template' in input.role) { id(input.role.template); if (!/^[a-f0-9]{64}$/.test(input.role.sha256??'') || Object.keys(input.role).length!==2) fail('invalid-request'); }
if ('definition' in input.role) { id(input.role.definition); if (!Number.isSafeInteger(input.role.rev) || Object.keys(input.role).length!==2) fail('invalid-request'); }
if ('inline' in input.role && Object.keys(input.role).length!==1) fail('invalid-request');
// #1873 triage-fence: no hire or change at any level copies a system-only template.
if (systemOnly(input.role.template)) fail(SYSTEM_ONLY_REFUSAL);
} else if (['role','route','credentials','personality'].some(k=>k in input)) fail('invalid-request');
const {document:doc,revision} = writer.read(business);
const loaded = validateBusinessDocument(doc,`${business}.json`,{rolesDir,dataRoot});
@@ -226,6 +228,7 @@ export function hireDecisions({ writer, rolesDir, configDir, dataRoot, assertCle
if ('template' in ref) { const template=readTemplate(rolesDir,ref.template); if(template.sha256!==ref.sha256) fail('decision-stale'); entry=entryFromTemplate(template); }
else if ('definition' in ref) { entry=doc.definitions?.[ref.definition]; if(!entry || entry.rev!==ref.rev) fail('definition-rev-conflict'); entry=structuredClone(entry); }
else entry={rev:1,role:{},instructions:''};
if (systemOnly(entry.from?.template)) fail(SYSTEM_ONLY_REFUSAL);
let c='inline' in ref ? structuredClone(ref.inline) : compositionOf(entry);
if ('credentials' in input) c.credentials=structuredClone(input.credentials);
if ('personality' in input) c.personality=structuredClone(input.personality);
@@ -387,5 +390,5 @@ export function hireDecisions({ writer, rolesDir, configDir, dataRoot, assertCle
const result=writer.reverseHireDecision(business,p,{...caller,beforeWrite:guard,beforePublish:publicationGuard});
return {...result,...(r.op==='change' && stopped?.running?{relaunch:publicOf(p)}:{})};
}
return {prepare,reverse,templates:()=>({templates:templateHashes(rolesDir).map(({template,sha256})=>({name:template,sha256}))}),preview:async(business,decision,caller)=>{const p=await adjusted(business,decision,caller.adjust);if(Date.parse(p.expiresAt)<=(caller.now??Date.now)())fail('decision-expired');authorizeHire(publicOf(p),caller);return publicOf(p);},rootRefusal,rootActive:name=>rootRefusal(name)===null,check:async(...args)=>{await check(...args);},apply,read: decision => publicOf(read(decision))};
return {prepare,reverse,templates:()=>({templates:templateHashes(rolesDir).filter(({template})=>!systemOnly(template)).map(({template,sha256})=>({name:template,sha256}))}),preview:async(business,decision,caller)=>{const p=await adjusted(business,decision,caller.adjust);if(Date.parse(p.expiresAt)<=(caller.now??Date.now)())fail('decision-expired');authorizeHire(publicOf(p),caller);return publicOf(p);},rootRefusal,rootActive:name=>rootRefusal(name)===null,check:async(...args)=>{await check(...args);},apply,read: decision => publicOf(read(decision))};
}
@@ -14,7 +14,7 @@ import { resolveInstance } from "./resolve.mjs";
import { loadRole } from "./role.mjs";
import { refuse } from "./errors.mjs";
import { isPlainObject, canonicalJson } from "./util.mjs";
import { CREATIVE_DEFINITIONS, CREATIVE_SERVICE, END_PROTECTED, HOST_SERVICE, ID_PATTERN, checkGrantScope, grantScopeOf } from "./vocabulary.mjs";
import { CREATIVE_DEFINITIONS, CREATIVE_SERVICE, END_PROTECTED, HOST_SERVICE, ID_PATTERN, SYSTEM_ONLY_REFUSAL, checkGrantScope, grantScopeOf, systemOnly } from "./vocabulary.mjs";
const SET_KEYS = ["revision", "instance", "op", "definition", "vars", "launch", "tracker"];
const VETO_KEYS = ["revision", "op", "name"];
@@ -93,6 +93,8 @@ const sameCredentialServices = (before, after) => credentialServices(before).joi
// Row 194 (brief item 7): the human's add passes credentials true and lifts it. The tester's add,
// change and hire keep it.
function definitionFor(rolesDir, name, { credentials = false } = {}) {
// #1873 triage-fence: no add or change of definition gives an instance a system-only template.
if (systemOnly(name)) throw new OrganizationError(SYSTEM_ONLY_REFUSAL);
if (closed(name)) throw new OrganizationError("organization-definition-refused");
const definition = loadRole(rolesDir, name);
if (definition.roleVersion !== 2) throw new OrganizationError("invalid-request", `role definition ${name} is version 1`);
@@ -153,6 +155,8 @@ export function instanceSettings({ dir, rolesDir, system, levels = () => null, r
const out = {};
for (const file of readdirSync(rolesDir).filter(f => f.endsWith(".json")).sort()) {
const name = file.slice(0, -5);
// #1873 triage-fence: the add list never offers a system-only template.
if (systemOnly(name)) continue;
let definition;
try {
definition = loadRole(rolesDir, name);
@@ -183,6 +187,8 @@ export function instanceSettings({ dir, rolesDir, system, levels = () => null, r
protected: closed(entry.definition),
kept: (launch?.keep ?? []).includes(name),
endProtected: protectedRefusal(document, name, actor) !== null,
// Ruling 2026-11-14: a hired instance names its hire decision; the bus adds the pack it came from.
...(typeof entry.hireDecision === 'string' ? { hireDecision: entry.hireDecision } : {}),
}]));
// Row 194 (D1): the human's forbid lists and the retired names. The bus adds running runs.
return {
+3
View File
@@ -94,6 +94,9 @@ export const VERB_RIGHTS = record({
'packs.console': 'board.read',
'pack.preview.console': null,
'pack.apply.console': null,
// Ruling 2026-11-14: hiring a pack's proposed agents is a hire; a member with org.hire gets the
// unflagged ones and the rest wait for the owner (invariant 7).
'pack.hire.console': 'org.hire',
'board.set.console': null,
'workflow.set.console': null,
// #1873 SP8: saving a template, and listing the saved ones, are the owner's alone: a template is a
+8 -4
View File
@@ -83,15 +83,18 @@ async function discoverPresets() {
}
return presets;
}
export async function orgPresets({ env = process.env } = {}) {
// `owner` (#1873 ride-default) is what the Console read from the owner's model proxy:
// {proxy, riding, models}. A preset that does not use it ignores it.
export async function orgPresets({ env = process.env, owner } = {}) {
const presets = await discoverPresets();
return Promise.all([...presets.values()].map(async p => {
const availability = await p.available({ env });
const availability = await p.available({ env, owner });
if (!availability || typeof availability.ok !== 'boolean' || (!availability.ok && (typeof availability.reason !== 'string' || !availability.reason))) fail('org-invalid', 'invalid preset availability');
return { name: p.name, label: p.label, description: p.description, thinking: structuredClone(p.thinking), available: availability.ok ? { ok: true } : { ok: false, reason: availability.reason } };
}));
}
export async function templateRender(id, { fixture, preset, thinking } = {}) {
// `model` (#1873 ride-default) is one row of the owner's catalogue, for a preset that routes to it.
export async function templateRender(id, { fixture, preset, thinking, model } = {}) {
if (fixture !== undefined && fixture !== 'local') fail('org-invalid', 'unknown fixture');
if (fixture !== undefined && preset !== undefined) fail('org-invalid', 'choose fixture or preset');
if (fixture === 'local') preset = 'fixture';
@@ -105,7 +108,8 @@ export async function templateRender(id, { fixture, preset, thinking } = {}) {
if (!p) fail('org-invalid', 'unknown preset');
const level = thinking === undefined ? p.thinking.default : thinking;
if (!p.thinking.levels.includes(level)) fail('org-invalid', 'unknown thinking level');
const overlay = await p.overlay({ thinking: level });
let overlay;
try { overlay = await p.overlay({ thinking: level, model }); } catch (e) { fail('org-invalid', e?.code === 'org-invalid' && typeof e.message === 'string' ? e.message : 'invalid preset overlay'); }
if (!overlay || typeof overlay !== 'object' || !overlay.plugins || !overlay.launch || !overlay.assistantVars) fail('org-invalid', 'invalid preset overlay');
doc.plugins = structuredClone(overlay.plugins); doc.launch = structuredClone(overlay.launch);
doc.roles.assistant.vars = structuredClone(overlay.assistantVars);
@@ -12,7 +12,7 @@ import { checkVars } from "./vars.mjs";
import { parseCredentialRef } from "./credentials.mjs";
import { loadRole } from "./role.mjs";
import { checkDefinition, checkDefinitions, checkDefinitionName, orgDefinitionName, ORG_PREFIX } from "./definitions.mjs";
import { END_PROTECTED, parseRepoRemote } from "./vocabulary.mjs";
import { END_PROTECTED, parseRepoRemote, SYSTEM_ONLY_REFUSAL, systemOnly } from "./vocabulary.mjs";
import { checkPlugins, checkUsageSettings, NAME as KIND_NAME } from "../../plugins/src/kinds.mjs";
import { checkMapping } from "../../library/src/mapping.mjs";
import { forkProblem, giteaName, parseGiteaUrl, HOST_SERVICE, CREATIVE_DEFINITIONS } from "./vocabulary.mjs";
@@ -113,6 +113,8 @@ function checkPin(pin, where) {
if (!shape) refuse(`${where} must be {template, sha256}, {definition, rev} or {inline}`);
if (shape[0] === "template") {
requireId(pin.template, `${where}.template`);
// #1873 triage-fence: no pack proposal pins a system-only template.
if (systemOnly(pin.template)) refuse(`${SYSTEM_ONLY_REFUSAL}: ${where}.template names ${pin.template}, a template no organization may hold`);
if (typeof pin.sha256 !== "string" || !HEX64.test(pin.sha256)) refuse(`${where}.sha256 must be 64 lowercase hex characters`);
} else if (shape[0] === "definition") {
checkDefinitionName(pin.definition, `${where}.definition`);
@@ -285,8 +287,11 @@ function checkRoles(roles, file, rolesDir, business, hasLibrary, orgDefinitions)
rejectUnknownKeys(entry, ["definition", "holder", "vars", "tracker", "credentials", "identity", "publish", "hosts", "hireDecision"], at);
// #1873 T1: "org:<name>" names one of this file's definitions; anything else is a template.
const orgName = orgDefinitionName(entry.definition);
if (orgName === null) requireId(entry.definition, `${at}.definition`);
else if (!Object.hasOwn(orgDefinitions, ORG_PREFIX + checkDefinitionName(orgName, `${at}.definition after org:`))) {
if (orgName === null) {
requireId(entry.definition, `${at}.definition`);
// #1873 triage-fence: no instance names a system-only template.
if (systemOnly(entry.definition)) refuse(`${SYSTEM_ONLY_REFUSAL}: ${at}.definition names ${entry.definition}, a template no organization may hold`);
} else if (!Object.hasOwn(orgDefinitions, ORG_PREFIX + checkDefinitionName(orgName, `${at}.definition after org:`))) {
refuse(`definition-missing: ${at}.definition names ${ORG_PREFIX}${orgName}, which definitions doesn't declare`);
}
const definition = Object.hasOwn(definitions, entry.definition) ? definitions[entry.definition]
+72 -56
View File
@@ -10,10 +10,13 @@
// (instance credentials, copyBindings, copyId, orgIncarnation, generation), launch, plugins, vars,
// project roots and git state, definition revs and hire decisions, and everything on the bus.
//
// Free text is kept, with the organization id, its project ids, its agent names, the owner's
// account and the project roots replaced by {org}, {project}, {agent}, {owner} and {root}. The
// preview lists each replacement and every kept free-text field by path, and the exact JSON save
// writes; save takes that JSON's digest. Every string and key is passed to the credential store's
// Free text is kept verbatim: save never rewrites prose (E2E6 fix 5, Lead ruling). A placeholder
// could stand only where a field's whole value is an organization identifier, and a pack carries no
// such field (hire names are <role>-<n>, step roles name definitions or templates), so save writes
// none and apply has none to resolve. The preview lists every kept free-text field by path, each
// one that mentions the organization id, a project id, an agent name, the owner's account or a
// project root (so the owner can edit it before saving), and the exact JSON save writes; save takes
// that JSON's digest. Every string and key is passed to the credential store's
// assertClean; a hit refuses template-secret-suspected naming the path, never the text.
//
// A refusal is a TemplateError: a bus code and a reason that names a path or a checked name only,
@@ -49,8 +52,8 @@ export const DEFAULT_BOARD = Object.freeze({
layout: "kanban",
});
const HIRE_REASON = "The organization this template was saved from ran this agent.";
// A word boundary for placeholder replacement: an identifier character on either side means the
// literal is part of a longer name, which stays as it is.
// A word boundary for a mention: an identifier character on either side means the literal is part of
// a longer name, which is not a mention.
const WORD = "A-Za-z0-9_-";
export class TemplateError extends Error {
@@ -100,63 +103,63 @@ function templateOrNull(rolesDir, name, cache) {
return cache.get(name);
}
// ---- Placeholders ----
// ---- Mentions ----
// The literals section 5 replaces, longest first so a root path is replaced before the ids inside
// it. A name that is also a template or a definition name is a role's name, not a person's or a
// client's, and stays: replacing "coder" would rewrite every role text that says coder.
function literals(document, { rolesDir, cache }) {
// The organization-specific names the preview looks for in kept text, longest first so a root path
// is found before the ids inside it. A name that is also a template or a definition name is a role's
// name, not a person's or a client's, and is not a mention: role text says "coder" on purpose. A
// mention is labelled by kind and name; a project root is labelled by kind alone, so the preview
// names no host path beyond the text it already shows.
function orgNames(document, { rolesDir, cache }) {
const out = [];
const add = (text, placeholder) => {
if (typeof text === "string" && text.length > 0 && !out.some((l) => l.text === text)) out.push({ text, placeholder });
const add = (text, label) => {
if (typeof text === "string" && text.length > 0 && !out.some((l) => l.text === text)) out.push({ text, label });
};
for (const project of Object.values(document.projects ?? {})) {
add(project?.root, "{root}");
add(project?.repo, "{root}");
add(project?.root, "project root");
add(project?.repo, "project root");
}
add(document.id, "{org}");
for (const id of Object.keys(document.projects ?? {})) add(id, "{project}");
add(document.human, "{owner}");
if (typeof document.id === "string") add(document.id, `organization ${document.id}`);
for (const id of Object.keys(document.projects ?? {})) add(id, `project ${id}`);
if (typeof document.human === "string") add(document.human, `owner ${document.human}`);
const role = (name) => Object.hasOwn(document.definitions ?? {}, name) || templateOrNull(rolesDir, name, cache) !== null;
const agents = new Set([...Object.keys(document.roles ?? {}), ...(Array.isArray(document.retired) ? document.retired : [])]);
for (const project of Object.values(document.projects ?? {})) for (const name of Object.keys(project?.agents ?? {})) agents.add(name);
for (const name of agents) if (!role(name)) add(name, "{agent}");
for (const name of agents) if (!role(name)) add(name, `agent ${name}`);
out.sort((a, b) => b.text.length - a.text.length);
return out;
}
// Returns the text with every literal replaced, and counts each placeholder used. One pass over the
// text with one alternation, longest literal first: a placeholder written in never matches a later
// literal, so an instance named "root" or "agent" cannot rewrite {root} or {agent}.
// The labels of every name the text mentions, in first-mention order, each once. One pass with one
// alternation, longest name first, so a root path is one mention and not the ids inside it.
const combined = new WeakMap();
function replace(text, list, counts) {
if (list.length === 0) return text;
function mentions(text, list) {
if (list.length === 0) return [];
let entry = combined.get(list);
if (!entry) {
const by = new Map(list.map((l) => [l.text, l.placeholder]));
const by = new Map(list.map((l) => [l.text, l.label]));
entry = { by, pattern: new RegExp(`(?<![${WORD}])(?:${list.map((l) => escape(l.text)).join("|")})(?![${WORD}])`, "g") };
combined.set(list, entry);
}
return text.replace(entry.pattern, (match) => {
const placeholder = entry.by.get(match);
counts[placeholder] = (counts[placeholder] ?? 0) + 1;
return placeholder;
});
const found = [];
for (const match of text.matchAll(entry.pattern)) {
const label = entry.by.get(match[0]);
if (!found.includes(label)) found.push(label);
}
return found;
}
// ---- Capture ----
// Builds the template document. With list null, free text is kept as it is (the scan's second
// copy); otherwise each replacement and each kept free-text field is recorded by path.
// Builds the template document. Free text is copied verbatim; each kept free-text field, and each
// one that mentions an organization-specific name, is recorded by path.
function capture(document, { name, project, rolesDir, list, record }) {
const cache = new Map();
const text = (value, path) => {
if (list === null) return value;
const counts = {};
const out = replace(value, list, counts);
for (const [placeholder, count] of Object.entries(counts)) record.replacements.push({ path, placeholder, count });
record.freeText.push({ path, text: out });
return out;
record.freeText.push({ path, text: value });
const names = mentions(value, list);
if (names.length > 0) record.mentions.push({ path, names });
return value;
};
const orgDefinitions = plain(document.definitions) ? document.definitions : {};
const scope = project === undefined ? "org" : "project";
@@ -233,7 +236,7 @@ function capture(document, { name, project, rolesDir, list, record }) {
if (!template) refuse("starter-pack-invalid", `${at}.from names a template that is not a version 2 role`);
// A template that changed since the definition copied it: the saved from names its current
// hash, and the role must still narrow the current template. The preview lists the re-pin.
if (template.sha256 !== entry.from.sha256 && list !== null) record.repinned.push(`${at}.from`);
if (template.sha256 !== entry.from.sha256) record.repinned.push(`${at}.from`);
out.from = { template: template.name, sha256: template.sha256 };
let composition;
try {
@@ -323,11 +326,12 @@ function capture(document, { name, project, rolesDir, list, record }) {
seen.add(k);
packs.push({ id: entry.id, version: entry.version });
}
if (list !== null) record.packsDropped = Math.max(0, packs.length - PACK_BOUNDS.packs);
record.packsDropped = Math.max(0, packs.length - PACK_BOUNDS.packs);
const keptPacks = packs.slice(Math.max(0, packs.length - PACK_BOUNDS.packs));
const label = name.slice(0, PACK_BOUNDS.label);
const descriptionText = scope === "org" ? "Saved from {org}." : "Saved from {project} in {org}.";
// No placeholder: apply copies the description as it stands, so a "{org}" here would stay literal.
const descriptionText = scope === "org" ? "Saved from an organization." : "Saved from one project of an organization.";
return {
packVersion: PACK_VERSION, id: name, version: "1.0.0", label, description: descriptionText, scope,
definitions, hires, board, workflows, skills, packs: keptPacks,
@@ -356,20 +360,16 @@ function scan(value, path, assertClean) {
}
}
// The preview: the exact JSON save writes, its digest, each replacement and each kept free-text
// field by path. Refuses before returning when any string or key holds a held credential value.
// The preview: the exact JSON save writes, its digest, each kept free-text field by path, each such
// field that mentions an organization-specific name, with the names it mentions, and each re-pin.
// Refuses before returning when any string or key holds a held credential value.
export function templatePreview({ document, name, project, rolesDir, assertClean }) {
checkTemplateName(name);
if (project !== undefined && (typeof project !== "string" || !ID_PATTERN.test(project))) refuse("invalid-request", "the project id is invalid");
if (typeof assertClean !== "function") throw new TypeError("templatePreview needs the credential store's assertClean");
if (!plain(document)) refuse("invalid-request", "the organization file is not readable");
const scope = { name, project, rolesDir };
// The scan reads both copies: the kept text before replacement (a held value a placeholder would
// break up still refuses) and the document save writes.
const raw = capture(document, { ...scope, list: null, record: null });
scan(raw, "", assertClean);
const record = { replacements: [], freeText: [], repinned: [], packsDropped: 0 };
const template = capture(document, { ...scope, list: literals(document, { rolesDir, cache: new Map() }), record });
const record = { freeText: [], mentions: [], repinned: [], packsDropped: 0 };
const template = capture(document, { name, project, rolesDir, list: orgNames(document, { rolesDir, cache: new Map() }), record });
scan(template, "", assertClean);
let checked;
try {
@@ -386,13 +386,27 @@ export function templatePreview({ document, name, project, rolesDir, assertClean
return {
name, scope: checked.scope, ...(project === undefined ? {} : { project }),
template: checked, json, digest: sha256(json),
replacements: record.replacements.sort(byPath), freeText: record.freeText.sort(byPath),
freeText: record.freeText.sort(byPath), mentions: record.mentions.sort(byPath),
repinned: record.repinned.sort(), packsDropped: record.packsDropped,
};
}
// ---- The file ----
const TEMPLATE_EXISTS = "a template of this name is already saved; save under another name";
// Whether a file (or anything, a symlink included) already holds the name. It looks only through a
// templates and an account directory that are real directories, so a link is never followed to say
// what lies elsewhere; any other case is left to the directory checks and the exclusive create.
function taken(templates, home, file) {
try {
if (!lstatSync(templates).isDirectory() || !lstatSync(home).isDirectory()) return false;
lstatSync(file);
return true;
} catch {
return false;
}
}
// A directory save writes under: real, the uid's own, writable by nobody else. The account's own
// directory is private (0700 or narrower), as readSavedTemplate requires.
function directory(path, uid, { private: closed }) {
@@ -413,23 +427,25 @@ function directory(path, uid, { private: closed }) {
}
// Save: the preview again, its digest compared, then the file created exclusively (wx, 0600). A
// name already saved refuses; nothing is replaced.
// name already saved refuses template-exists; nothing is replaced. The name is checked before the
// digest, so a save under a taken name says so even when the preview is stale.
export function templateSave({ document, name, project, digest, rolesDir, assertClean, configDir, account, uid = process.getuid() }) {
checkAccount(account);
checkTemplateName(name);
if (typeof digest !== "string" || !/^[0-9a-f]{64}$/.test(digest)) refuse("invalid-request", "save takes the preview's digest");
const preview = templatePreview({ document, name, project, rolesDir, assertClean });
if (preview.digest !== digest) refuse("pack-plan-stale", "the organization or a template changed since the preview");
const templates = join(configDir, "templates");
const home = join(templates, account);
const file = join(home, `${name}.json`);
if (taken(templates, home, file)) refuse("template-exists", TEMPLATE_EXISTS);
const preview = templatePreview({ document, name, project, rolesDir, assertClean });
if (preview.digest !== digest) refuse("pack-plan-stale", "the organization or a template changed since the preview");
directory(templates, uid, { private: false });
directory(home, uid, { private: true });
const file = join(home, `${name}.json`);
let fd;
try {
fd = openSync(file, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
} catch (error) {
if (error?.code === "EEXIST") refuse("invalid-request", "a template of this name is already saved");
if (error?.code === "EEXIST") refuse("template-exists", TEMPLATE_EXISTS);
refuse("not-configured", "the template file cannot be created");
}
try {
+9
View File
@@ -209,6 +209,15 @@ export const THREAD_DEFINITIONS = Object.freeze([THREAD_DEFINITION, ...CREATIVE_
// organization write may give an instance one of them, except the human's instances.set for a
// creative definition (row 213).
export const END_PROTECTED = THREAD_DEFINITIONS;
// #1873 lane triage-fence: the shipped templates no organization may hold. Jason approved the
// Triage template on 2026-11-16; its use outside an organization waits for his ruling. Every path
// by which an organization could gain a role reads this list and refuses with SYSTEM_ONLY_REFUSAL:
// a hire or change at org, project or root level, a pack preview or apply, instances.set, the
// organization file's own validation, and every template list a page offers. The template itself
// still loads and validates as a template.
export const SYSTEM_ONLY = Object.freeze(["triage"]);
export const SYSTEM_ONLY_REFUSAL = "template-system-only";
export const systemOnly = name => typeof name === "string" && SYSTEM_ONLY.includes(name);
// Row 199 (#1697, design D9c): the Gitea URL parse. It lives here because the broker reads it and
// this file imports nothing. Gitea's name rule for users and repositories: letters, digits, "_", "."
@@ -30,3 +30,45 @@ test('unknown presets and thinking levels refuse', async () => {
await assert.rejects(templateRender('alpha', { preset: 'claude-code', thinking: 'off' }), /thinking/);
await assert.rejects(templateRender('alpha', { thinking: 'low' }), /thinking/);
});
// #1873 ride-default slice 1: the cliproxy preset routes a new organization to a model the
// owner's catalogue lists, and says plainly why it is unavailable.
const row = (over = {}) => ({ key: 'claude-claude-opus-5-5', module: 'cliproxy', upstream: 'claude', provider: 'anthropic', model: 'claude-opus-5-5',
label: 'claude / claude-opus-5-5', available: true, reason: null, harnesses: ['claude-code', 'pi'], ...over });
const cliproxyOf = async owner => (await service.orgPresets({ env: { PATH: '/usr/bin:/bin' }, owner })).find(p => p.name === 'cliproxy');
test('the cliproxy preset is discovered and names each reason it is unavailable', async () => {
const none = await cliproxyOf(undefined);
assert.equal(none.available.ok, false); assert.match(none.available.reason, /Set up the model proxy first/);
assert.match((await cliproxyOf({ proxy: false, riding: true, models: [row()] })).available.reason, /Set up the model proxy first/);
assert.match((await cliproxyOf({ proxy: true, riding: false, models: [row()] })).available.reason, /No organization uses the model proxy yet/);
assert.match((await cliproxyOf({ proxy: true, riding: true, models: [] })).available.reason, /lists no model you can use/);
for (const bad of [row({ available: false }), row({ reason: 'unverified' }), row({ module: 'fixture' }), row({ harnesses: [] })])
assert.match((await cliproxyOf({ proxy: true, riding: true, models: [bad] })).available.reason, /lists no model you can use/);
const ok = await cliproxyOf({ proxy: true, riding: true, models: [row()] });
assert.deepEqual(ok.available, { ok: true });
assert.deepEqual(ok.thinking, { levels: ['low', 'medium', 'high', 'xhigh', 'max'], default: 'low' });
});
test('the cliproxy overlay routes to the catalogue model it is given and validates', async () => {
const doc = await templateRender('alpha', { preset: 'cliproxy', model: row() });
assert.deepEqual(doc.plugins['model-provider'], ['cliproxy']);
assert.deepEqual(doc.launch.models, { 'claude-claude-opus-5-5': { provider: 'anthropic', model: 'claude-opus-5-5', module: 'cliproxy', upstream: 'claude' } });
assert.deepEqual(doc.roles.assistant.vars, { harness: 'claude-code', model: 'claude-claude-opus-5-5', thinking: 'low' });
assert.equal(doc.vars, undefined);
assert.deepEqual(await validateOrg(doc), { ok: true, errors: [] });
const glm = await templateRender('alpha', { preset: 'cliproxy', thinking: 'high', model: row({ key: 'zai-glm-5-3', upstream: 'zai', provider: 'zai', model: 'glm-5.3', harnesses: ['pi'] }) });
assert.deepEqual(glm.roles.assistant.vars, { harness: 'pi', model: 'zai-glm-5-3', thinking: 'high' });
assert.deepEqual(glm.plugins.harness, ['pi']);
assert.deepEqual(await validateOrg(glm), { ok: true, errors: [] });
await assert.rejects(templateRender('alpha', { preset: 'cliproxy' }), /lists no such model/);
await assert.rejects(templateRender('alpha', { preset: 'cliproxy', model: row({ available: false }) }), /lists no such model/);
});
test('existing presets ignore the new model and owner inputs', async () => {
assert.deepEqual(await templateRender('alpha', { preset: 'fixture', model: row() }), await templateRender('alpha', { preset: 'fixture' }));
assert.deepEqual(await templateRender('alpha', { preset: 'claude-code', model: row() }), await templateRender('alpha', { preset: 'claude-code' }));
const presets = await service.orgPresets({ env: { PATH: '/usr/bin:/bin' }, owner: { proxy: true, riding: true, models: [row()] } });
assert.equal(presets.find(p => p.name === 'fixture').available.ok, true);
assert.equal(presets.find(p => p.name === 'claude-code').available.ok, false);
});
@@ -86,6 +86,7 @@ const VERBS = {
'packs.console': 'board.read',
'pack.preview.console': null,
'pack.apply.console': null,
'pack.hire.console': 'org.hire',
'board.set.console': null,
'workflow.set.console': null,
// Starter packs SP8 (#1873): saving a template and listing the saved ones are the owner's alone.
@@ -0,0 +1,209 @@
// #1873 lane triage-fence: the Triage template is system-only. Jason approved the template on
// 2026-11-16; no organization may hold it until he rules on its use outside one. Every place an
// organization could gain it refuses with one code, template-system-only, and the template itself
// still loads and validates as a template. Fixtures live in a temp directory.
import test from "node:test";
import assert from "node:assert/strict";
import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
import { join } from "node:path";
import { tmpdir } from "node:os";
// A namespace import, so a run against the commit before the fence fails test by test, not at load.
import * as vocabulary from "../src/vocabulary.mjs";
import { checkDefinition, entryFromTemplate, readTemplate, templateHash, templateHashes } from "../src/definitions.mjs";
import { loadRole } from "../src/role.mjs";
import { validateBusinessDocument } from "../src/organization-config.mjs";
import { checkProjectAgents, checkRootAgents } from "../src/agent-levels.mjs";
import { hireDecisions } from "../src/hire-decisions.mjs";
import { instanceSettings } from "../src/instance-settings.mjs";
import { definitionVerbs } from "../src/definition-verbs.mjs";
import { organizationWriter } from "../src/organization.mjs";
import { ROLE_RIGHTS } from "../src/org-rights.mjs";
import { checkPack, installedStarterPacks } from "../../plugins/src/starter-pack.mjs";
import { businessDoc, rolesCopy, systemFor, tmp, writeJson } from "./helpers.mjs";
const CODE = "template-system-only";
const coded = (e) => e?.code === CODE;
const prefixed = (e) => e?.name === "BusinessError" && e.message.startsWith(`${CODE}: `);
const OWNER = { actor: "jason", agent: false, rights: ["org.hire"], owner: true, instanceOwner: true, subject: { provider: "test", iss: "https://test", sub: "owner" } };
const DEF_OWNER = { actor: "jason", rights: [...ROLE_RIGHTS.owner], agent: false };
const ROUTE = { harness: "pi", model: "claude-opus-5-5" };
function rootDir(t) {
const root = tmp();
t.after(() => rmSync(root, { recursive: true, force: true }));
return root;
}
function hireSetup(t) {
const root = mkdtempSync(join(tmpdir(), "so-"));
t.after(() => rmSync(root, { recursive: true, force: true }));
const rolesDir = rolesCopy(root);
writeJson(join(root, "businesses/demo.json"), { ...businessDoc(root, "demo"), plugins: { harness: ["pi"] } });
const writer = organizationWriter({ dir: root, rolesDir });
const dataRoot = join(root, "data");
mkdirSync(dataRoot, { mode: 0o700 });
const service = hireDecisions({ writer, rolesDir, configDir: root, dataRoot, assertClean: () => {} });
const triage = { template: "triage", sha256: templateHash(rolesDir, "triage") };
let n = 0;
const prepare = (extra) => service.prepare("demo", { op: "hire", level: "org", name: "sorter", role: triage, route: ROUTE, reason: "Sort the inbox", ...extra },
{ id: `1111111${n++}-1111-4111-8111-111111111111`, expiresAt: "2099-01-01T00:00:00.000Z" });
return { root, rolesDir, writer, service, prepare, triage };
}
function settingsSetup(t) {
const root = rootDir(t);
const rolesDir = rolesCopy(root);
const dir = join(root, "config");
const doc = businessDoc(root, "acme");
doc.plugins = { harness: ["pi", "claude-code"] };
writeJson(join(dir, "businesses", "acme.json"), doc);
return { rolesDir, settings: instanceSettings({ dir, rolesDir, system: systemFor(root) }) };
}
function verbsSetup(t) {
const root = rootDir(t);
const dir = join(root, "config");
const rolesDir = rolesCopy(root);
writeJson(join(dir, "businesses/acme.json"), businessDoc(root));
const writer = organizationWriter({ dir, rolesDir });
return { root, dir, rolesDir, writer, verbs: definitionVerbs({ writer, rolesDir, assertClean: () => {} }) };
}
test("the list is one name, triage, and its refusal code is template-system-only", () => {
assert.deepEqual([...(vocabulary.SYSTEM_ONLY ?? [])], ["triage"]);
assert.equal(vocabulary.SYSTEM_ONLY_REFUSAL, CODE);
assert.equal(vocabulary.systemOnly?.("triage"), true);
assert.equal(vocabulary.systemOnly?.("coder"), false);
assert.equal(vocabulary.systemOnly?.(undefined), false);
});
test("triage still loads and validates as a template", (t) => {
const rolesDir = rolesCopy(rootDir(t));
const role = loadRole(rolesDir, "triage");
assert.equal(role.roleVersion, 2);
const source = readTemplate(rolesDir, "triage");
assert.match(source.sha256, /^[a-f0-9]{64}$/);
assert.ok(templateHashes(rolesDir).some(({ template }) => template === "triage"));
});
test("hire refuses a triage template at org level", async (t) => {
const f = hireSetup(t);
await assert.rejects(f.prepare(), coded);
});
test("hire refuses a triage template at project level", async (t) => {
const f = hireSetup(t);
await assert.rejects(f.prepare({ level: "project", project: "stack" }), coded);
});
test("hire refuses a triage template at root level", async (t) => {
const f = hireSetup(t);
await assert.rejects(f.prepare({ level: "root" }), coded);
});
test("a change refuses to move an org instance onto triage", async (t) => {
const f = hireSetup(t);
await assert.rejects(f.prepare({ op: "change", name: "coder" }), coded);
});
test("the hire template list a page offers omits triage and keeps every other template", (t) => {
const f = hireSetup(t);
const offered = f.service.templates().templates.map(({ name }) => name);
assert.ok(!offered.includes("triage"));
assert.deepEqual(offered, templateHashes(f.rolesDir).map(({ template }) => template).filter((n) => n !== "triage"));
});
test("instances add refuses triage for the human and the tester", (t) => {
const f = settingsSetup(t);
for (const actor of ["jason", "tester"]) {
const revision = f.settings.read("acme").revision;
assert.throws(() => f.settings.set("acme", { revision, instance: "sorter", op: "add", definition: "triage" }, actor), coded, actor);
}
});
test("instances change of definition refuses triage", (t) => {
const f = settingsSetup(t);
const revision = f.settings.read("acme").revision;
assert.throws(() => f.settings.set("acme", { revision, instance: "coder", op: "change", definition: "triage" }, "jason"), coded);
});
test("the instances add list omits triage", (t) => {
const f = settingsSetup(t);
assert.equal(Object.hasOwn(f.settings.read("acme").definitions, "triage"), false);
});
test("an organization file whose roles name triage is refused", (t) => {
const root = rootDir(t);
const rolesDir = rolesCopy(root);
const doc = businessDoc(root);
doc.roles.sorter = { definition: "triage" };
assert.throws(() => validateBusinessDocument(doc, join(root, "acme.json"), { rolesDir }), prefixed);
});
test("an organization definition copied from triage is refused", (t) => {
const rolesDir = rolesCopy(rootDir(t));
const entry = entryFromTemplate(readTemplate(rolesDir, "triage"));
assert.throws(() => checkDefinition("sorter", entry), prefixed);
});
test("a root agent naming triage is refused", (t) => {
const rolesDir = rolesCopy(rootDir(t));
assert.throws(() => checkRootAgents({ agentsVersion: 1, agents: { sorter: { definition: "triage" } } }, { rolesDir }), prefixed);
});
test("a project agent naming triage is refused", (t) => {
const rolesDir = rolesCopy(rootDir(t));
assert.throws(() => checkProjectAgents({ sorter: { definition: "triage" } }, { rolesDir, where: "projects.stack.agents" }), prefixed);
});
test("a pack record proposing a triage hire is refused", (t) => {
const root = rootDir(t);
const rolesDir = rolesCopy(root);
const doc = businessDoc(root);
doc.packs = [{ id: "coding", version: "1.0.0", sha256: "a".repeat(64), origin: "shipped", scope: "org", project: null,
at: "2026-11-12T20:00:00.000Z", by: "jason", added: [], proposedHires: [{ name: "sorter-1", pin: { template: "triage", sha256: "a".repeat(64) } }] }];
assert.throws(() => validateBusinessDocument(doc, join(root, "acme.json"), { rolesDir }), prefixed);
});
test("import refuses triage and the definitions template list omits it", (t) => {
const f = verbsSetup(t);
const revision = f.writer.read("acme").revision;
assert.throws(() => f.verbs.import("acme", { revision, template: "triage" }, DEF_OWNER), coded);
const listed = f.verbs.templates().map(({ template }) => template);
assert.deepEqual(listed, templateHashes(f.rolesDir).map(({ template }) => template).filter((n) => n !== "triage"));
});
test("a starter pack naming triage is refused when checked", async (t) => {
const rolesDir = rolesCopy(rootDir(t));
const { starterPack } = await import("../../plugins/starter-pack/coding/index.mjs");
const doc = starterPack();
doc.definitions = { ...doc.definitions, triage: { template: "triage", sha256: templateHash(rolesDir, "triage") } };
assert.throws(() => checkPack(doc, { origin: "installed", rolesDir, name: doc.id }), coded);
});
// The guard: the fence changes nothing for any other template or any shipped pack.
test("every other shipped template imports as before and every shipped pack loads unchanged", async (t) => {
const f = verbsSetup(t);
const all = templateHashes(f.rolesDir).map(({ template }) => template);
const others = all.filter((n) => n !== "triage");
assert.equal(others.length, all.length - 1);
// Each template's import outcome, measured on 5c7194e05 before the fence: chief-of-staff carries
// role.hire, which a hired agent may not hold, so its import refused before and still does.
const refusedBefore = ["chief-of-staff"];
const outcome = {};
for (const template of others) {
try {
f.verbs.import("acme", { revision: f.writer.read("acme").revision, template }, DEF_OWNER);
outcome[template] = "imported";
} catch (e) {
assert.ok(!String(e.message).includes(CODE) && e.code !== CODE, template);
outcome[template] = "refused";
}
}
assert.deepEqual(Object.keys(outcome).filter((n) => outcome[n] === "refused"), refusedBefore.filter((n) => others.includes(n)));
const defs = f.writer.read("acme").document.definitions;
assert.deepEqual(Object.keys(defs).sort(), others.filter((n) => outcome[n] === "imported").sort());
const { packs, refused } = await installedStarterPacks({ dataRoot: null });
assert.deepEqual(refused, []);
assert.deepEqual(packs.map((p) => p.id).sort(), ["business-management", "coding", "creative-writing", "marketing", "montage"]);
});
@@ -1,6 +1,7 @@
// Starter packs SP8 (#1873): saving an organization or one of its projects as a template. The saved
// file carries no credential material and no member, keeps each role's credential request lines,
// replaces the organization's own names with placeholders, and reads back as an origin-saved pack.
// keeps free text verbatim (E2E6 fix 5) while the preview lists the fields that mention the
// organization's own names, and reads back as an origin-saved pack.
import test from "node:test";
import assert from "node:assert/strict";
import { chmodSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
@@ -94,34 +95,56 @@ test("SP8 the saved file keeps each role's credential request lines", (t) => {
assert.ok(template.definitions.writer.role.credentials.length > 0);
});
test("SP8 placeholders replace the org and project ids, the owner, agent names and project roots, in free text only", (t) => {
// E2E6 fix 5, red before: the old save rewrote prose word by word, so a project named "work" turned
// "hand finished work to review" into "hand finished {project} to review", and apply never resolves
// a placeholder. Save now keeps every free-text field as it stands.
test("E2E6 red before: save never rewrites prose; a project named work leaves \"hand finished work to review\" as it is", (t) => {
const { doc, rolesDir } = fixture(t);
doc.projects.work = { ...structuredClone(doc.projects.stack), root: join(doc.projects.stack.root, "..", "work-root") };
doc.workflows.change.steps[1].title = "hand finished work to review";
const preview = templatePreview({ document: doc, name: "team-shape", rolesDir, assertClean });
assert.equal(preview.template.workflows.change.steps[1].title, "hand finished work to review");
assert.ok(!preview.json.includes("{project}"));
// The owner sees the mention and may edit the text before saving.
assert.deepEqual(preview.mentions.find((m) => m.path === "workflows.change.steps[1].title"), { path: "workflows.change.steps[1].title", names: ["project work"] });
});
test("E2E6 free text is kept verbatim, no placeholder is written, and the preview lists each field that mentions an org-specific name", (t) => {
const { doc, rolesDir } = fixture(t);
const preview = templatePreview({ document: doc, name: "team-shape", rolesDir, assertClean });
const { template } = preview;
assert.equal(template.definitions.writer.instructions, "Write code for {org} in {root}/src. Ask {owner}; pair with {agent} on {project}.");
assert.equal(template.definitions.writer.personality.summary, "Careful {org} engineer.");
assert.deepEqual(template.definitions.writer.personality.traits, ["works with {agent}", "plain"]);
assert.equal(template.board.columns[0].label, "{org} backlog");
assert.equal(template.workflows.change.description, "Change for {project}");
assert.equal(template.workflows.change.steps[0].title, "{agent} writes it");
// Agent names that are role names (pm, coder) stay; role text says "coder" on purpose.
const all = JSON.stringify(template);
for (const literal of ["acme", "jason", "ana", doc.projects.stack.root]) assert.ok(!all.includes(literal), literal);
assert.equal(template.description, "Saved from {org}.");
// Each replacement is listed by path.
const at = (path) => preview.replacements.filter((r) => r.path === path).map((r) => r.placeholder).sort();
assert.deepEqual(at("definitions.writer.instructions"), ["{agent}", "{org}", "{owner}", "{project}", "{root}"]);
assert.equal(template.definitions.writer.instructions, doc.definitions.writer.instructions);
assert.equal(template.definitions.writer.personality.summary, "Careful acme engineer.");
assert.deepEqual(template.definitions.writer.personality.traits, ["works with ana", "plain"]);
assert.equal(template.board.columns[0].label, "acme backlog");
assert.equal(template.workflows.change.description, "Change for stack");
assert.equal(template.workflows.change.steps[0].title, "ana writes it");
for (const placeholder of ["{org}", "{project}", "{agent}", "{owner}", "{root}"]) assert.ok(!preview.json.includes(placeholder), placeholder);
assert.equal(template.description, "Saved from an organization.");
assert.ok(!Object.hasOwn(preview, "replacements"));
const at = (path) => preview.mentions.find((m) => m.path === path)?.names;
// A root path is one mention, labelled by kind alone, not the ids inside it.
assert.deepEqual(at("definitions.writer.instructions"), ["organization acme", "project root", "owner jason", "agent ana", "project stack"]);
assert.deepEqual(at("definitions.writer.personality.traits[1]"), undefined);
assert.deepEqual(at("board.columns[0].label"), ["organization acme"]);
// Role names (writer, coder) are not mentions; a longer word holding a name is not one either.
assert.equal(at("board.columns[1].label"), undefined);
doc.board.columns[1].label = "acmes and anas";
assert.equal(templatePreview({ document: doc, name: "team-shape", rolesDir, assertClean }).mentions.find((m) => m.path === "board.columns[1].label"), undefined);
// Every mention is a kept free-text field, in path order.
const paths = preview.mentions.map((m) => m.path);
assert.deepEqual(paths, [...paths].sort());
for (const p of paths) assert.ok(preview.freeText.some((f) => f.path === p), p);
});
test("SP8 an instance named root, org or agent never rewrites a placeholder already written in", (t) => {
test("E2E6 text that looks like a placeholder, or an instance named root, org or agent, stays verbatim", (t) => {
const { doc, rolesDir } = fixture(t);
doc.roles.root = { definition: "org:writer" };
doc.roles.org = { definition: "org:writer" };
doc.definitions.writer.instructions = "Work for acme with root on stack. Ask org, then jason.";
doc.definitions.writer.instructions = "Work for acme with root on stack. Ask org, then jason. Keep {org} and {agent} literal.";
const preview = templatePreview({ document: doc, name: "team-shape", rolesDir, assertClean });
assert.equal(preview.template.definitions.writer.instructions, "Work for {org} with {agent} on {project}. Ask {agent}, then {owner}.");
const at = preview.replacements.filter((r) => r.path === "definitions.writer.instructions").map((r) => r.placeholder).sort();
assert.deepEqual(at, ["{agent}", "{org}", "{owner}", "{project}"]);
assert.equal(preview.template.definitions.writer.instructions, doc.definitions.writer.instructions);
assert.deepEqual(preview.mentions.find((m) => m.path === "definitions.writer.instructions").names, ["organization acme", "agent root", "project stack", "agent org", "owner jason"]);
});
test("SP8 the preview lists every kept free-text field with its saved text", (t) => {
@@ -151,7 +174,7 @@ test("SP8 a held credential in kept text refuses template-secret-suspected namin
doc.definitions.writer.personality.voice = `short, key ${TOKEN}`;
refused(() => templatePreview({ document: doc, name: "acme-shape", rolesDir, assertClean }), "template-secret-suspected", "definitions.writer.personality.voice");
try { templatePreview({ document: doc, name: "acme-shape", rolesDir, assertClean }); } catch (e) { assert.ok(!e.message.includes(TOKEN)); }
// A held value a placeholder would split still refuses: the scan reads the text before replacement.
// A held value inside other text still refuses: the scan reads the text save keeps.
const second = fixture(t);
second.doc.workflows.change.steps[1].title = `acme${TOKEN}`;
refused(() => templatePreview({ document: second.doc, name: "acme-shape", rolesDir: second.rolesDir, assertClean }), "template-secret-suspected", "workflows.change.steps[1].title");
@@ -170,7 +193,9 @@ test("SP8 a second save to the same name refuses and leaves the first file", (t)
const first = readFileSync(file);
doc.definitions.writer.instructions = "Changed.";
const next = templatePreview({ document: doc, name: "acme-shape", rolesDir, assertClean });
refused(() => templateSave({ document: doc, name: "acme-shape", digest: next.digest, rolesDir, assertClean, configDir, account: "jason" }), "invalid-request", "a template of this name is already saved");
refused(() => templateSave({ document: doc, name: "acme-shape", digest: next.digest, rolesDir, assertClean, configDir, account: "jason" }), "template-exists", "a template of this name is already saved; save under another name");
// E2E6 fix 8: the name is checked first, so a stale or malformed-but-valid digest still says the name is taken.
refused(() => templateSave({ document: doc, name: "acme-shape", digest: "0".repeat(64), rolesDir, assertClean, configDir, account: "jason" }), "template-exists");
assert.deepEqual(readFileSync(file), first);
assert.equal(lstatSync(file).mode & 0o777, 0o600);
assert.equal(lstatSync(join(configDir, "templates", "jason")).mode & 0o777, 0o700);
@@ -246,7 +271,7 @@ test("SP8 a project template carries the project's agents, the definitions it na
assert.deepEqual(Object.keys(template.definitions).sort(), ["reviewer", "writer"]);
assert.deepEqual(template.board, JSON.parse(JSON.stringify(DEFAULT_BOARD)));
assert.deepEqual(template.workflows, {});
assert.equal(template.description, "Saved from {project} in {org}.");
assert.equal(template.description, "Saved from one project of an organization.");
refused(() => templatePreview({ document: doc, name: "x", project: "nope", rolesDir, assertClean }), "invalid-request");
});
+22
View File
@@ -258,6 +258,28 @@ export returns:
`gateTimeout`, `bundle`, `env`, `turnEnd`, `outputPolicy` and `transcript` give its
sandbox binds, web, tool names, S0 lines, bundle files, adapter variables,
how a turn ends and where its transcripts land.
- `envNames` and `installRoots({env})` (#1873 triage-fences) are optional and
outside `kinds.mjs`. A session the Console hosts with no organization
(Triage) reads them; organization launches do not. `envNames` lists the
names `env()` returns, less the provider's. The host takes a route's
`harnessEnv` name only when it is listed here and is not one the host
always refuses: `MOSAIC_*`, `NODE_*`, `LD_*`, `DYLD_*`, `PYTHON*`, `BASH_*`,
`GIT_*`, `MALLOC_*`, `NPM_CONFIG_*`, `XDG_*`, any name ending in `_DIR`,
`_CONF`, `_CONFIG`, `_ASKPASS`, `_CA_BUNDLE` or `_BASE_URL`, PATH, HOME,
TMPDIR, ENV, the founder's and the provider's names, and named shell,
proxy, resolver, libc, OpenSSL and Java hooks, Perl and Ruby start
options and library paths, less's input filters, Lua's start code,
curl's config home and a TLS key log. The full list is
`REFUSED_NAMES` in `packages/webui/src/triage-host.mjs`. `installRoots` lists the directories
where the adapter and the mounts live. A hosted adapter or mount source
must resolve inside one of them, and never in or around the data root,
the config directory, HOME, `/srv/mosaic` or a path with a `secret`
segment. HOME does not count against a source inside the stack's own
code, so a copy or a worktree under HOME still passes. Every claude-code
name is `MOSAIC_*`, so a hosted session cannot run Claude Code yet. pi's
`MOSAIC_TOOLS`, `MOSAIC_EXTENSIONS` and `MOSAIC_THINKING` are refused the
same way, so a hosted pi gets no tools and no extension until the host
sets those names itself.
- `compactions({store, cursors, budget, streams, first})` reads a thread
session's native store for row 270's compaction count (row 307). Core keeps
the ledger (`packages/seat/src/compactions.mjs`) and passes `store` as
+11 -1
View File
@@ -6,7 +6,7 @@
// session.json. packages/plugins/README.md lists the interface.
import { spawnSync } from "node:child_process";
import { accessSync, constants, realpathSync, statSync } from "node:fs";
import { delimiter, isAbsolute, join } from "node:path";
import { delimiter, dirname, isAbsolute, join } from "node:path";
import { fileURLToPath } from "node:url";
import { claudeBuiltins, MCP_PREFIX } from "../../../harness/src/gate.mjs";
import { hasSessionCredential, SESSION_CREDENTIALS } from "../../../seat/src/session.mjs";
@@ -145,6 +145,16 @@ export function env({ files, policy, session, proxy = null }) {
};
}
// #1873 triage-fences: the names env() returns, less the proxy's, and the directories its adapter
// and mounts live in: the pinned binary's when MOSAIC_CLAUDE_BIN is set. A hosted session's host
// (Triage) takes harnessEnv names and mount sources only from these; launches don't read them.
export const envNames = Object.freeze(["MOSAIC_TOOLS", "MOSAIC_CLAUDE_SETTINGS", "MOSAIC_CLAUDE_MCP_CONFIG", "MOSAIC_THINKING", "MOSAIC_MODEL_ACTIVITY_SOURCE"]);
export function installRoots({ env = {} } = {}) {
const roots = [join(REPO, "adapters", "claude"), join(REPO, "tools", "unslop-hook")];
if (env.MOSAIC_CLAUDE_BIN) roots.push(dirname(realpathSync(env.MOSAIC_CLAUDE_BIN)));
return roots;
}
// A turn ends when claude exits; there is no marker.
export const turnEnd = () => "exit";
export const transcript = ({ runDir, store = null }) => (store ? store.projects : join(runDir, "home", ".claude", "projects"));
+8
View File
@@ -118,6 +118,14 @@ export function env({ policy, tools, session, proxy = null }) {
};
}
// #1873 triage-fences: the names env() returns, less the provider key, and the directories its
// adapter and mounts live in. A hosted session's host (Triage) takes harnessEnv names and mount
// sources only from these; launches don't read them. The host refuses every MOSAIC_* name from a
// route, so MOSAIC_TOOLS, MOSAIC_EXTENSIONS and MOSAIC_THINKING are listed only to say what env()
// hands a session: a hosted pi needs the host to set them itself (a later slice).
export const envNames = Object.freeze(["PI_OFFLINE", "MOSAIC_TOOLS", "MOSAIC_EXTENSIONS", "PI_PROVIDER", "PI_MODEL", "MOSAIC_THINKING"]);
export const installRoots = () => [join(REPO, "adapters", "pi"), join(REPO, "packages", "plugins", "harness", "pi"), realpathSync(join(REPO, "node_modules")), join(REPO, "tools", "unslop-hook")];
// The extension writes the turn marker at agent_end; an exit without it is a failed turn.
export const turnEnd = () => "marker";
export const transcript = ({ runDir, store = null }) => (store ? store.session : join(runDir, "session"));
@@ -76,3 +76,32 @@ export function route({ selection, harness }) {
if (typeof selection.model !== 'string' || !MODEL.test(selection.model)) return { code: 'model-provider-unavailable' };
return { provider: selection.provider ?? upstream, model: selection.model, upstream, ...ROUTES[upstream] };
}
// #1873 ride-default slice 1: a new organization that uses the owner's models through the
// instance's model proxy. The Console reads the owner's catalogue from a riding bus and passes
// it as `owner`; this module never reaches the proxy itself.
const THINKING = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
export const usableModel = m => !!m && m.module === 'cliproxy' && m.available === true && m.reason === null
&& typeof m.key === 'string' && /^[a-z][a-z0-9-]{0,63}$/.test(m.key) && typeof m.upstream === 'string' && Object.hasOwn(ROUTES, m.upstream)
&& typeof m.provider === 'string' && typeof m.model === 'string' && MODEL.test(m.model)
&& Array.isArray(m.harnesses) && (m.harnesses.includes('claude-code') || m.harnesses.includes('pi'));
export function orgPresets() {
return [{ name: 'cliproxy', label: 'Your models through the model proxy',
description: 'Uses a model your model proxy lists. Each reply spends your own account.',
thinking: { levels: [...THINKING], default: 'low' },
available: ({ owner } = {}) => {
if (!owner || owner.proxy !== true) return { ok: false, reason: 'Set up the model proxy first, on the Model proxy page.' };
if (owner.riding !== true) return { ok: false, reason: 'No organization uses the model proxy yet, or none answered. Use Ride all on the Model proxy page.' };
if (!Array.isArray(owner.models) || !owner.models.some(usableModel)) return { ok: false, reason: 'The model proxy lists no model you can use. Sign in to an account on the Model proxy page.' };
return { ok: true };
},
overlay: ({ thinking, model }) => {
if (!usableModel(model)) throw Object.assign(Error('the model proxy lists no such model'), { code: 'org-invalid' });
const harness = model.harnesses.includes('claude-code') ? 'claude-code' : 'pi';
return {
plugins: { channel: ['cli', 'webui'], harness: [harness], 'model-provider': ['cliproxy'] },
launch: { by: 'chief', instances: ['assistant'], models: { [model.key]: { provider: model.provider, model: model.model, module: 'cliproxy', upstream: model.upstream } } },
assistantVars: { harness, model: model.key, thinking },
};
} }];
}
+4 -1
View File
@@ -20,7 +20,7 @@ import { fileURLToPath } from "node:url";
import { types } from "node:util";
import { ENTRY_KEYS, checkDefinition, readTemplate } from "../../organization/src/definitions.mjs";
import { parseJsonFileText } from "../../organization/src/util.mjs";
import { ID_PATTERN, NETWORKS } from "../../organization/src/vocabulary.mjs";
import { ID_PATTERN, NETWORKS, SYSTEM_ONLY_REFUSAL, systemOnly } from "../../organization/src/vocabulary.mjs";
import { NAME, PluginError } from "./kinds.mjs";
import { hasModule, loadInstalled } from "./loader.mjs";
@@ -163,6 +163,9 @@ function checkDefinitions(definitions, { origin, rolesDir, id }) {
const at = `starter pack definitions.${name}`;
const entry = definitions[name];
if (!plain(entry)) fail("starter-pack-invalid", `${at} must be a JSON object`, id);
// #1873 triage-fence: a pack never carries a system-only template, as a reference or as a from.
const named = entry.template ?? (plain(entry.from) ? entry.from.template : undefined);
if (systemOnly(named)) fail(SYSTEM_ONLY_REFUSAL, `${at} names template ${named}, which no organization may hold`, id);
const keys = Object.keys(entry);
if (keys.length === REF_KEYS.length && REF_KEYS.every((k) => keys.includes(k))) {
// A template reference: the whole template, pinned by its hash.
+157 -1
View File
@@ -34,7 +34,7 @@
// the launch (sandbox-unavailable).
import { spawnSync } from "node:child_process";
import { existsSync, lstatSync, mkdirSync, readlinkSync, realpathSync } from "node:fs";
import { existsSync, lstatSync, mkdirSync, readlinkSync, realpathSync, statSync } from "node:fs";
import { dirname, isAbsolute, join, relative, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import { ID_PATTERN } from "../../organization/src/vocabulary.mjs";
@@ -193,6 +193,162 @@ export function sandboxArgv(list, runDir, command, { business, role, bwrap = BWR
return [bwrap, ...NAMESPACES, ...argsOf(list), "--remount-ro", "/", "--setenv", "HOME", join(runDir, "home"), "--setenv", "TMPDIR", "/tmp", ...identity, "--chdir", runDir, "--", ...KILL_WITH_PARENT, ...command];
}
// #1873 triage-fences: what a model route may hand a hosted session, checked before the host
// writes anything and again in hostedBinds. The adapter and each mount's source must be a clean
// absolute path whose real path lies under one of the harness module's install roots, named under
// that same root, and outside every protected path: the data root, the config directory and HOME
// the caller passes, the run directory, ALWAYS_PROTECTED, and any path with a segment that
// contains "secret" in any case. A protected path counts in its own spelling and its real path, and
// a source may neither lie inside one nor contain one. The bind's source is the real path, so a
// link swapped after the check cannot steer it. A mount's dest (its source when it names none) is
// never /tmp, the run directory or a system bind's dest, nor inside or around one, never a parent
// of or equal to a runner file, the adapter or node, and never in or around another mount's dest.
// At most HOSTED_MOUNTS_MAX mounts. A refusal is a HostedRouteError naming its fence, never a path.
// `codeRoot` is the stack's own code and `codeHolder` the one protected path that may hold it:
// HOME, when the stack runs from a copy or a worktree under it. That path does not refuse a source
// whose named and real paths both lie in the code root. Every other check still applies to it, and
// no other protected path, the run directory or ALWAYS_PROTECTED is ever set aside. A code root in
// or around the run directory or ALWAYS_PROTECTED, in either path's spelling or real path, is refused.
export const HOSTED_MOUNTS_MAX = 8;
const ROOTS_MAX = 16;
const PATH_MAX = 4096;
const ALWAYS_PROTECTED = Object.freeze(["/srv/mosaic", "/proc", "/sys", "/dev", "/run", "/root", "/boot"]);
const MOUNT_KEYS = Object.freeze(["src", "dest", "why"]);
export class HostedRouteError extends Error {
constructor(fence, message) {
super(`hosted binds: ${message}`);
this.code = "hosted-binds-refused";
this.fence = fence;
}
}
const refuseRoute = (fence, message) => { throw new HostedRouteError(fence, message); };
// Absolute, already normal (no "..", ".", "//" or trailing slash), not "/", no NUL.
const cleanPath = (p) => typeof p === "string" && p.length > 1 && p.length <= PATH_MAX && !p.includes("\0") && isAbsolute(p) && resolve(p) === p;
const within = (child, parent) => child === parent || child.startsWith(parent + "/");
const overlaps = (a, b) => within(a, b) || within(b, a);
const secretPath = (p) => p.split("/").some((seg) => /secret/i.test(seg));
const realOr = (p) => { try { return realpathSync(p); } catch { return p; } };
const plainObject = (o) => o !== null && typeof o === "object" && !Array.isArray(o) && [Object.prototype, null].includes(Object.getPrototypeOf(o));
// `alsoFixed` is a test hook: it adds stand-in fixed paths and never removes a shipped one.
export function checkHostedRoute({ adapter, harnessMounts, installRoots, protectedPaths, codeRoot = null, codeHolder = null, runDir, node = process.execPath, alsoFixed = [] }) {
if (!cleanPath(runDir)) refuseRoute("protected", "the run directory is not a clean absolute path");
if (!Array.isArray(protectedPaths)) refuseRoute("protected", "no protected paths were given");
if (!Array.isArray(alsoFixed)) refuseRoute("protected", "the added fixed paths are not a list");
// Lists are copied once, so a Proxy cannot answer one length to a check and another to the map.
protectedPaths = Array.from(protectedPaths);
// Each guarded entry: its spellings, and whether a source in the code root is clear of it. The
// fixed paths and the run dir never hold the code. Their spellings are looked up once, here, and
// serve both the code-root check and their guards, so the two always see the same real path.
const fixed = [...ALWAYS_PROTECTED, ...Array.from(alsoFixed), runDir].map((p) => {
if (!cleanPath(p)) refuseRoute("protected", "a protected path is not a clean absolute path");
return { spellings: [p, realOr(p)], holdsCode: false };
});
let code = null;
if (codeRoot !== null) {
if (!cleanPath(codeRoot)) refuseRoute("protected", "the code root is not a clean absolute path");
if (!protectedPaths.includes(codeHolder)) refuseRoute("protected", "the code root's holder is not a protected path");
code = [codeRoot, realOr(codeRoot)];
if (code.some((c) => fixed.some((g) => g.spellings.some((s) => overlaps(c, s))))) refuseRoute("protected", "the code root is in or around a path that is never set aside");
}
const guarded = [...fixed];
for (const p of protectedPaths) {
if (!cleanPath(p)) refuseRoute("protected", "a protected path is not a clean absolute path");
const spellings = [p, realOr(p)];
const holdsCode = p === codeHolder && code !== null && spellings.some((g) => code.some((c) => c !== g && within(c, g)));
guarded.push({ spellings, holdsCode });
}
if (!Array.isArray(installRoots)) refuseRoute("roots", "the harness module declares no usable install roots");
installRoots = Array.from(installRoots);
if (installRoots.length === 0 || installRoots.length > ROOTS_MAX) refuseRoute("roots", "the harness module declares no usable install roots");
const roots = installRoots.map((r) => {
if (!cleanPath(r)) refuseRoute("roots", "an install root is not a clean absolute path");
let real;
try { real = realpathSync(r); } catch { refuseRoute("roots", "an install root is missing"); }
if (real === "/" || !statSync(real).isDirectory()) refuseRoute("roots", "an install root is not a directory");
return { named: r, real };
});
const source = (src, fence, what) => {
if (!cleanPath(src)) refuseRoute(fence, `${what} is not a clean absolute path`);
let real;
try { real = realpathSync(src); } catch { refuseRoute(fence, `${what} is missing`); }
if (!roots.some((r) => (within(src, r.named) || within(src, r.real)) && within(real, r.real))) refuseRoute(fence, `${what} is not under an install root`);
const inCode = code !== null && code.some((c) => within(src, c)) && within(real, code[1]);
if (guarded.some((g) => !(g.holdsCode && inCode) && [src, real].some((p) => g.spellings.some((s) => overlaps(p, s))))) refuseRoute(fence, `${what} is in or around a protected path`);
if ([src, real].some(secretPath)) refuseRoute(fence, `${what} is in a secrets path`);
return real;
};
const adapterReal = source(adapter, "adapter", "the adapter");
if (!statSync(adapterReal).isFile()) refuseRoute("adapter", "the adapter is not a file");
if (!Array.isArray(harnessMounts)) refuseRoute("mounts", `a hosted session takes at most ${HOSTED_MOUNTS_MAX} harness mounts`);
harnessMounts = Array.from(harnessMounts);
if (harnessMounts.length > HOSTED_MOUNTS_MAX) refuseRoute("mounts", `a hosted session takes at most ${HOSTED_MOUNTS_MAX} harness mounts`);
const apart = ["/tmp", runDir, ...systemBinds(node).map((b) => b.dest ?? b.src)];
const kept = [...RUNNER_FILES, adapter, node];
const dests = [];
const mounts = harnessMounts.map((m, i) => {
const what = `harness mount ${i + 1}`;
if (!plainObject(m) || Object.keys(m).some((k) => !MOUNT_KEYS.includes(k))) refuseRoute("mounts", `${what} is not { src, dest, why }`);
// Each field is read once, so a getter cannot answer one value to a check and another to the bind.
const { src, dest: named, why } = m;
if (typeof why !== "string" || !why || why.length > 256) refuseRoute("mounts", `${what} is not { src, dest, why }`);
if (named !== undefined && !cleanPath(named)) refuseRoute("mount-dest", `${what}'s dest is not a clean absolute path`);
const real = source(src, "mount-src", what);
const dest = named ?? src;
if (apart.some((p) => overlaps(dest, p)) || kept.some((p) => within(p, dest)) || dests.some((d) => overlaps(dest, d))) refuseRoute("mount-dest", `${what}'s dest would cover a path the session needs`);
dests.push(dest);
return { src: real, dest, why };
});
return { adapter: { src: adapterReal, dest: adapter }, mounts };
}
// #1873 triage-host: the binds for a session the Console hosts in no organization (Triage). It
// gets the system part, the runner's files, the adapter and the harness module's mounts like any
// session, and from the data root exactly two directories: its own `runDir` read-write, and
// `healthDir` read-only over runDir/work/health, inside the workspace the read tools' gate allows. The run's bundle/, session.json and the relay socket the runner
// calls through stay read-only inside it, and its tmp/ is /tmp. There is no workspace, broker,
// launch or git socket, thread store or org root. Each source inside runDir must be what the host
// just made there, never a link the session left: bwrap resolves a bind's source on the host.
// The adapter and the mounts pass checkHostedRoute against `installRoots`, `protectedPaths` and
// `codeRoot` with its `codeHolder` here too; without install roots nothing binds.
export function hostedBinds({ runDir, healthDir, adapter, harnessMounts = [], installRoots, protectedPaths, codeRoot = null, codeHolder = null, relaySocket, node = process.execPath, readOnly = [] }) {
if (relaySocket !== join(runDir, "relay.sock")) throw new Error("hosted binds: the relay socket must be the run directory's relay.sock");
const healthDest = join(runDir, "work", "health");
for (const p of [runDir, healthDir, join(runDir, "bundle"), join(runDir, "tmp"), join(runDir, "work"), healthDest]) {
let st;
try { st = lstatSync(p); } catch { throw new Error(`hosted binds: ${p === healthDir ? "the health directory" : relative(runDir, p) || "the run directory"} is missing`); }
if (st.isSymbolicLink() || !st.isDirectory()) throw new Error(`hosted binds: ${p === healthDir ? "the health directory" : relative(runDir, p) || "the run directory"} is not a directory`);
}
for (const [p, ok] of [[join(runDir, "session.json"), (st) => st.isFile()], [relaySocket, (st) => st.isSocket()]]) {
let st;
try { st = lstatSync(p); } catch { throw new Error(`hosted binds: ${relative(runDir, p)} is missing`); }
if (!ok(st)) throw new Error(`hosted binds: ${relative(runDir, p)} is not what the host made`);
}
const route = checkHostedRoute({ adapter, harnessMounts, installRoots, protectedPaths, codeRoot, codeHolder, runDir, node });
const out = systemBinds(node);
for (const f of RUNNER_FILES) out.push({ kind: "ro", src: f, why: "a repository file the runner loads" });
out.push({ kind: "ro", src: route.adapter.src, ...(route.adapter.src !== adapter ? { dest: adapter } : {}), why: "the harness adapter the runner starts each turn" });
for (const m of route.mounts) out.push({ kind: "ro", src: m.src, ...(m.dest !== m.src ? { dest: m.dest } : {}), why: m.why });
for (const f of readOnly) out.push({ kind: "ro", src: f, why: "a test fixture" });
out.push(
{ kind: "rw", src: runDir, why: "the session's own state: turns/, session/, work/, tools.sock, turn.done, home/, tmp/" },
{ kind: "ro", src: healthDir, dest: healthDest, why: "the health snapshots the Console writes, read-only, inside the workspace the read tools reach" },
{ kind: "ro", src: join(runDir, "bundle"), why: "the run's bundle stays as the host wrote it" },
{ kind: "ro", src: join(runDir, "session.json"), why: "the session file stays as the host wrote it" },
{ kind: "ro", src: relaySocket, why: "the host's relay, the only broker the runner reaches" },
{ kind: "rw", src: join(runDir, "tmp"), dest: "/tmp", why: "a private /tmp, on disk in the run directory" },
);
return out;
}
// The command line for a hosted session: as sandboxArgv, with no git identity, since a hosted
// session belongs to no organization and holds no git verb.
export function hostedArgv(list, runDir, command, { bwrap = BWRAP } = {}) {
return [bwrap, ...NAMESPACES, ...argsOf(list), "--remount-ro", "/", "--setenv", "HOME", join(runDir, "home"), "--setenv", "TMPDIR", "/tmp", "--chdir", runDir, "--", ...KILL_WITH_PARENT, ...command];
}
// Whether bwrap runs here at all: the namespaces and the system binds, then
// setpriv and `true`. Returns null, or why not.
export function sandboxProblem({ bwrap = BWRAP } = {}) {
+245
View File
@@ -0,0 +1,245 @@
// #1873 triage-host: the binds of a session the Console hosts in no organization. From the data root
// it gets its own run directory and the health directory, read-only, and nothing else; every source
// inside the run directory must be what the host made, never a link.
import { test } from "node:test";
import assert from "node:assert/strict";
import { createServer } from "node:net";
import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
import { dirname, join } from "node:path";
import { HOSTED_MOUNTS_MAX, RUNNER_FILES, checkHostedRoute, hostedArgv, hostedBinds } from "../src/sandbox.mjs";
function layout(t) {
const root = mkdtempSync(join(process.env.TMPDIR, "hb-"));
const dataRoot = join(root, "data");
const runDir = join(dataRoot, "triage", "agent");
const healthDir = join(dataRoot, "triage", "health");
for (const d of [join(dataRoot, "orgs"), join(dataRoot, "triage", "host"), healthDir, join(runDir, "bundle"), join(runDir, "tmp"), join(runDir, "work", "health")]) mkdirSync(d, { recursive: true });
writeFileSync(join(runDir, "session.json"), "{}");
const install = join(root, "install");
mkdirSync(install);
const adapter = join(install, "adapter.sh");
writeFileSync(adapter, "exit 0\n");
return new Promise((resolve) => {
const server = createServer().listen(join(runDir, "relay.sock"), () => {
t.after(() => server.close());
resolve({ root, dataRoot, runDir, healthDir, adapter, install, relaySocket: join(runDir, "relay.sock"), installRoots: [install], protectedPaths: [dataRoot] });
});
});
}
test("hosted binds hold the run directory and the health directory of the data root, and nothing else of it", async (t) => {
const p = await layout(t);
const list = hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths });
const fromData = list.filter((b) => typeof b.src === "string" && b.src.startsWith(p.dataRoot + "/"));
assert.deepEqual(fromData.map((b) => [b.kind, b.src, b.dest ?? null]), [
["rw", p.runDir, null],
["ro", p.healthDir, join(p.runDir, "work", "health")],
["ro", join(p.runDir, "bundle"), null],
["ro", join(p.runDir, "session.json"), null],
["ro", p.relaySocket, null],
["rw", join(p.runDir, "tmp"), "/tmp"],
]);
for (const f of RUNNER_FILES) assert.ok(list.some((b) => b.kind === "ro" && b.src === f), f);
assert.ok(list.some((b) => b.kind === "ro" && b.src === p.adapter));
assert.ok(!list.some((b) => b.src === p.root || b.src === p.dataRoot || (typeof b.src === "string" && b.src.startsWith(join(p.dataRoot, "orgs")))));
assert.ok(!list.some((b) => b.src === process.env.HOME || b.dest === process.env.HOME));
assert.ok(list.every((b) => typeof b.why === "string" && b.why.length > 0));
});
test("hosted binds refuse a relay socket elsewhere, and any source in the run directory that the host did not make", async (t) => {
const p = await layout(t);
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths };
assert.throws(() => hostedBinds({ ...base, relaySocket: join(p.root, "bus.sock") }), /relay socket must be the run directory's relay\.sock/);
// A link in place of each directory the binds read: bwrap would follow it on the host.
for (const d of ["bundle", "tmp", "work"]) {
rmSync(join(p.runDir, d), { recursive: true });
symlinkSync(join(p.dataRoot, "orgs"), join(p.runDir, d));
assert.throws(() => hostedBinds(base), /is not a directory/, d);
rmSync(join(p.runDir, d));
mkdirSync(join(p.runDir, d === "work" ? join("work", "health") : d), { recursive: true });
}
rmSync(join(p.runDir, "work", "health"), { recursive: true });
symlinkSync(join(p.dataRoot, "triage", "host"), join(p.runDir, "work", "health"));
assert.throws(() => hostedBinds(base), /is not a directory/);
rmSync(join(p.runDir, "work", "health"));
mkdirSync(join(p.runDir, "work", "health"));
rmSync(join(p.runDir, "session.json"));
symlinkSync(join(p.dataRoot, "orgs"), join(p.runDir, "session.json"));
assert.throws(() => hostedBinds(base), /session\.json is not what the host made/);
rmSync(join(p.runDir, "session.json"));
writeFileSync(join(p.runDir, "session.json"), "{}");
assert.throws(() => hostedBinds({ ...base, healthDir: join(p.root, "absent") }), /the health directory is missing/);
hostedBinds(base);
});
test("the hosted command line sets no git identity and runs the command under the namespaces", async (t) => {
const p = await layout(t);
const argv = hostedArgv(hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths }), p.runDir, ["node", "runner.mjs", p.runDir], { bwrap: "/b/bwrap" });
assert.equal(argv[0], "/b/bwrap");
assert.deepEqual(argv.slice(1, 5), ["--unshare-user", "--unshare-pid", "--unshare-ipc", "--as-pid-1"]);
assert.deepEqual(argv.slice(-3), ["node", "runner.mjs", p.runDir]);
assert.ok(!argv.some((a) => a.startsWith("GIT_")));
const home = argv.indexOf("HOME");
assert.equal(argv[home + 1], join(p.runDir, "home"));
assert.ok(argv.includes("--remount-ro"));
});
// #1873 triage-fences: hostedBinds checks the adapter and the mounts again, so a caller that skips
// the host's own check still binds nothing outside the install roots.
test("hosted binds refuse without install roots or protected paths, and refuse an adapter or a mount source outside the roots or in a protected path", async (t) => {
const p = await layout(t);
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths };
const refused = (opts, fence, label) => assert.throws(() => hostedBinds({ ...base, ...opts }), (e) => e.code === "hosted-binds-refused" && e.fence === fence, label);
refused({ installRoots: undefined }, "roots", "no roots");
refused({ installRoots: [] }, "roots", "empty roots");
refused({ installRoots: ["/"] }, "roots", "root /");
refused({ installRoots: [join(p.root, "absent")] }, "roots", "missing root");
refused({ installRoots: [p.adapter] }, "roots", "a file as root");
refused({ protectedPaths: undefined }, "protected", "no protected paths");
refused({ protectedPaths: ["relative"] }, "protected", "relative protected path");
writeFileSync(join(p.root, "out.sh"), "x");
refused({ adapter: join(p.root, "out.sh") }, "adapter", "adapter outside");
symlinkSync(join(p.root, "out.sh"), join(p.install, "link.sh"));
refused({ adapter: join(p.install, "link.sh") }, "adapter", "adapter link out");
refused({ adapter: p.install }, "adapter", "adapter is a directory");
refused({ harnessMounts: [{ src: join(p.install, "link.sh"), why: "w" }] }, "mount-src", "mount link out");
refused({ harnessMounts: [{ src: join(p.dataRoot, "orgs"), why: "w" }], installRoots: [p.root] }, "mount-src", "mount in the data root");
refused({ harnessMounts: [{ src: p.root, why: "w" }], installRoots: [p.root] }, "mount-src", "mount around the data root");
mkdirSync(join(p.install, "secrets"));
writeFileSync(join(p.install, "secrets", "k"), "x");
refused({ harnessMounts: [{ src: join(p.install, "secrets", "k"), why: "w" }] }, "mount-src", "mount in secrets");
writeFileSync(join(p.install, "m"), "x");
refused({ harnessMounts: Array.from({ length: HOSTED_MOUNTS_MAX + 1 }, (_, i) => ({ src: join(p.install, "m"), dest: `/opt/m${i}`, why: "w" })) }, "mounts", "too many");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: "/tmp/m", why: "w" }] }, "mount-dest", "dest under /tmp");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: p.runDir, why: "w" }] }, "mount-dest", "dest is the run dir");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: join(p.runDir, "session.json"), why: "w" }] }, "mount-dest", "dest is session.json");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: "/usr", why: "w" }] }, "mount-dest", "dest is a system bind");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: dirname(RUNNER_FILES[0]), why: "w" }] }, "mount-dest", "dest holds a runner file");
refused({ harnessMounts: [{ src: join(p.install, "m"), why: "w", kind: "rw" }] }, "mounts", "a kind of its own");
});
test("hosted binds bind the real file of a link that stays inside the install root, at the path the route named", async (t) => {
const p = await layout(t);
writeFileSync(join(p.install, "real.mjs"), "x");
symlinkSync(join(p.install, "real.mjs"), join(p.install, "named.mjs"));
symlinkSync(p.adapter, join(p.install, "adapter-link.sh"));
const list = hostedBinds({
runDir: p.runDir, healthDir: p.healthDir, adapter: join(p.install, "adapter-link.sh"), relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths,
harnessMounts: [{ src: join(p.install, "named.mjs"), why: "w" }, { src: join(p.install, "real.mjs"), dest: "/opt/real.mjs", why: "w2" }],
});
assert.ok(list.some((b) => b.kind === "ro" && b.src === p.adapter && b.dest === join(p.install, "adapter-link.sh")));
assert.ok(list.some((b) => b.kind === "ro" && b.src === join(p.install, "real.mjs") && b.dest === join(p.install, "named.mjs") && b.why === "w"));
assert.ok(list.some((b) => b.kind === "ro" && b.src === join(p.install, "real.mjs") && b.dest === "/opt/real.mjs" && b.why === "w2"));
assert.ok(!list.some((b) => b.src === join(p.install, "named.mjs")));
});
test("a protected path that holds the code root (HOME over a copy or a worktree) does not refuse a source inside the code root; everything else still holds", async (t) => {
const p = await layout(t);
// home/ holds the code root code/, which holds the install root.
const home = join(p.root, "home");
const code = join(home, "code");
const inst = join(code, "inst");
mkdirSync(join(inst, "secrets"), { recursive: true });
for (const f of ["adapter.sh", "m", join("secrets", "k")]) writeFileSync(join(inst, f), "x");
writeFileSync(join(home, "outside"), "x");
mkdirSync(join(code, "data"));
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: join(inst, "adapter.sh"), relaySocket: p.relaySocket, installRoots: [inst], protectedPaths: [p.dataRoot, home], codeRoot: code, codeHolder: home };
const refused = (opts, fence, label) => assert.throws(() => hostedBinds({ ...base, ...opts }), (e) => e.code === "hosted-binds-refused" && e.fence === fence, label);
const list = hostedBinds({ ...base, harnessMounts: [{ src: join(inst, "m"), dest: "/opt/m", why: "w" }] });
assert.ok(list.some((b) => b.src === join(inst, "adapter.sh")) && list.some((b) => b.src === join(inst, "m") && b.dest === "/opt/m"));
// Without the code root, HOME refuses the same adapter.
refused({ codeRoot: null }, "adapter", "no code root");
// A code root that is HOME itself sets nothing aside.
refused({ codeRoot: home }, "adapter", "code root is HOME");
// A source under HOME outside the code root, even inside an install root.
refused({ installRoots: [home], adapter: join(home, "outside") }, "adapter", "outside the code root");
// A link inside the code root to a file outside it.
symlinkSync(join(home, "outside"), join(inst, "out"));
refused({ installRoots: [inst, home], harnessMounts: [{ src: join(inst, "out"), why: "w" }] }, "mount-src", "link out of the code root");
// A protected path inside the code root still refuses.
writeFileSync(join(code, "data", "f"), "x");
refused({ installRoots: [code], protectedPaths: [p.dataRoot, home, join(code, "data")], harnessMounts: [{ src: join(code, "data", "f"), why: "w" }] }, "mount-src", "protected path in the code root");
// The secrets check still holds inside the code root.
refused({ harnessMounts: [{ src: join(inst, "secrets", "k"), why: "w" }] }, "mount-src", "secrets in the code root");
// The run directory and the fixed list are never set aside, and a code root around them is refused.
refused({ codeRoot: p.root, installRoots: [p.root], harnessMounts: [{ src: join(p.dataRoot, "orgs"), why: "w" }] }, "protected", "code root holds the run dir");
refused({ codeRoot: "/srv/mosaic/x" }, "protected", "code root in a fixed path");
refused({ codeRoot: "relative" }, "protected", "relative code root");
// Only the named holder sets the code aside: another protected path that holds the code still refuses.
refused({ protectedPaths: [p.dataRoot, home, p.root] }, "adapter", "a second protected path holds the code");
refused({ codeHolder: null }, "protected", "no holder");
refused({ codeHolder: join(p.root, "elsewhere") }, "protected", "a holder that is not a protected path");
// A run directory named through a link: a code root in its real path is refused before any check.
const realRun = join(home, "run");
mkdirSync(join(realRun, "code", "inst"), { recursive: true });
writeFileSync(join(realRun, "code", "inst", "a.sh"), "x");
symlinkSync(realRun, join(p.root, "runlink"));
assert.throws(() => checkHostedRoute({ adapter: join(realRun, "code", "inst", "a.sh"), harnessMounts: [], installRoots: [join(realRun, "code", "inst")], protectedPaths: [p.dataRoot, home], codeRoot: join(realRun, "code"), codeHolder: home, runDir: join(p.root, "runlink") }), (e) => e.fence === "protected", "code root in the run dir's real path");
});
test("a fixed path named through a link: a code root in its real path is refused before any guard, and a source there is refused by its guard", async (t) => {
const p = await layout(t);
// None of the shipped fixed paths is a link on a test host, so the test hook adds a stand-in.
const home = join(p.root, "home");
// The real path lies outside HOME and the data root, so only the stand-in's own guard can refuse
// a source there.
const real = join(p.root, "fixedreal");
const inst = join(real, "code", "inst");
mkdirSync(inst, { recursive: true });
writeFileSync(join(inst, "a.sh"), "x");
const link = join(p.root, "fixedlink");
symlinkSync(real, link);
const base = { adapter: join(inst, "a.sh"), harnessMounts: [], installRoots: [inst], protectedPaths: [p.dataRoot, home], codeHolder: home, runDir: p.runDir, alsoFixed: [link] };
const refused = (opts, fence, message, label) => assert.throws(() => checkHostedRoute({ ...base, ...opts }), (e) => e.code === "hosted-binds-refused" && e.fence === fence && message.test(e.message), label);
// The code root lies in the stand-in's real path, not under the name the list gives.
refused({ codeRoot: join(real, "code") }, "protected", /never set aside/, "code root in a fixed path's real path");
// With the code root in HOME, the source in the stand-in's real path is refused by the stand-in's
// guard, which holds the same real spelling. No other guard holds that path.
mkdirSync(join(home, "code"), { recursive: true });
refused({ codeRoot: join(home, "code") }, "adapter", /protected path/, "source in a fixed path's real path");
// The same source passes without the stand-in: only the stand-in refused it.
assert.equal(checkHostedRoute({ ...base, alsoFixed: [], codeRoot: join(home, "code") }).adapter.src, join(inst, "a.sh"));
// The hook adds fixed paths and never removes one, and takes only a list of clean absolute paths.
refused({ alsoFixed: [], codeRoot: "/srv/mosaic/x" }, "protected", /never set aside/, "shipped fixed path with an empty hook");
refused({ alsoFixed: ["relative"], codeRoot: join(real, "code") }, "protected", /clean absolute/, "relative stand-in");
refused({ alsoFixed: "/x", codeRoot: join(real, "code") }, "protected", /clean absolute|list/, "a hook that is not a list");
});
test("a list that answers one length to the check and another later is read once", async (t) => {
const p = await layout(t);
const items = [];
for (let i = 0; i <= HOSTED_MOUNTS_MAX; i++) { writeFileSync(join(p.install, `m${i}`), "x"); items.push({ src: join(p.install, `m${i}`), dest: `/opt/m${i}`, why: "w" }); }
let reads = 0;
const mounts = new Proxy(items, { get: (o, k) => (k === "length" ? (reads++ === 0 ? 1 : o.length) : o[k]) });
assert.throws(() => checkHostedRoute({ adapter: p.adapter, harnessMounts: mounts, installRoots: p.installRoots, protectedPaths: p.protectedPaths, runDir: p.runDir }), (e) => e.fence === "mounts");
// Install roots: two short answers pass the count, then a long one would add roots the count never saw.
const roots = [];
for (let i = 0; i <= 16; i++) { roots.push(join(p.root, `r${i}`)); mkdirSync(roots[i]); }
writeFileSync(join(roots[16], "a.sh"), "x");
let rootReads = 0;
const rootList = new Proxy(roots, { get: (o, k) => (k === "length" ? (rootReads++ < 2 ? 1 : o.length) : o[k]) });
assert.throws(() => checkHostedRoute({ adapter: join(roots[16], "a.sh"), harnessMounts: [], installRoots: rootList, protectedPaths: p.protectedPaths, runDir: p.runDir }), (e) => e.fence === "adapter");
// Protected paths: the holder check sees HOME, then a shorter answer would leave HOME unguarded.
const home = join(p.root, "home");
mkdirSync(join(home, "code"), { recursive: true });
writeFileSync(join(home, "f"), "x");
let guardReads = 0;
const guards = new Proxy([p.dataRoot, home], { get: (o, k) => (k === "length" ? (guardReads++ === 0 ? 2 : 1) : o[k]) });
assert.throws(() => checkHostedRoute({ adapter: p.adapter, harnessMounts: [{ src: join(home, "f"), dest: "/opt/f", why: "w" }], installRoots: [p.install, home], protectedPaths: guards, codeRoot: join(home, "code"), codeHolder: home, runDir: p.runDir }), (e) => e.fence === "protected" || e.fence === "mount-src");
});
test("each mount field is read once, and no mount's dest lies in or around another's", async (t) => {
const p = await layout(t);
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths };
writeFileSync(join(p.install, "m"), "x");
writeFileSync(join(p.install, "n"), "x");
let reads = 0;
const list = hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), why: "w", get dest() { return reads++ === 0 ? undefined : "/opt/../tmp"; } }] });
assert.equal(reads, 1);
assert.ok(list.some((b) => b.src === join(p.install, "m") && b.dest === undefined));
assert.ok(!list.some((b) => b.dest === "/opt/../tmp"));
for (const [a, b] of [["/opt/x", "/opt/x/f"], ["/opt/x/f", "/opt/x"], ["/opt/x", "/opt/x"]]) {
assert.throws(() => hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), dest: a, why: "w" }, { src: join(p.install, "n"), dest: b, why: "w" }] }), (e) => e.fence === "mount-dest", `${a} then ${b}`);
}
assert.equal(hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), dest: "/opt/x", why: "w" }, { src: join(p.install, "n"), dest: "/opt/xy", why: "w" }] }).filter((b) => b.dest?.startsWith("/opt/")).length, 2);
});
+33
View File
@@ -25,6 +25,7 @@ baseline CLI.
| Restart the Console | Stop and run `mosaic console start` again | Enabled (F3) when `mosaic console start` runs it in the foreground, or with `--dev-local-owner --detach` under a detached supervisor (D1): Settings > Console; the owner only; trailed. Other Consoles answer `not-supervised` |
| Save, review, confirm or reverse an organization's autonomy | Read, save and review: `mosaic org autonomy ORG`, `mosaic org autonomy ORG set --revision REV [--cross-role|--merge|--policy|--authority in|near|out] [--notices on|off] [--reverse-window-hours 1-168] [--authority-resolver NAME|""]`, `mosaic org autonomy ORG review CLASS` (E2, through this route and its revision check); confirm and reverse act on inbox decisions and have no verb yet | Enabled (D1) on a `--dev-local-owner` Console: the owner only, on the selected organization's bus, behind a fence that passes only the four console verbs `autonomy.set.console`, `autonomy.review.console`, `decision.confirm.console` and `decision.reverse.console` |
| Hire, fire or change an agent; read role templates | `mosaic org role-templates ORG`; `mosaic org hire|change ORG --name NAME --template TEMPLATE --harness H --model M [--thinking T] [--level org|project|root] [--project P] --reason TEXT`; `mosaic org fire ORG --name NAME [--level ...] --reason TEXT` (E2, through this route) | Enabled (D4) for the owner on a selected organization's bus: one decision raised and approved through `hire.start.console`, with the bus's hire checks |
| Apply a starter pack; hire its proposed agents; fire an agent from its card | `mosaic org pack preview|apply ID PACK [--digest D] [--project P]`; `mosaic org pack hire ID PACK [--project P]`; `mosaic org fire ORG --name NAME --reason TEXT` | Enabled for the owner (ruling 2026-11-14): applying is the hire decision; see "Starter pack hires" |
| Create, edit or archive a board task | `mosaic tasks create --title T --requirement REQ [--project P] [--state S] [--assignees R,...] [--priority 0-5] [--due ISO|none]`; `mosaic tasks edit task:N --expect DIGEST ...`; `mosaic tasks archive task:N --expect DIGEST` (E2: the board's own check, then the person's `tasks.create|edit|archive` on the bus) | Enabled for the owner on an organization with the built-in task store |
| Create chat project linked to a configured repository | `mosaic project create <name> --repo <project> --org <id>` | Enabled |
| Create a thread | `mosaic thread create <project> <name> --org <id>` | Planned enabled |
@@ -70,6 +71,38 @@ as the owner's page can. The startup warning says so. Use a dev instance for UI
testing only. The real boundary is sign-in (`--sso`); a refusal for local agent
peers in dev mode is a recorded follow-up.
### Starter pack hires (ruling 2026-11-14, #1873)
"Damnit. If I choose a starter pack and apply it, that is a decision!"
`POST /api/orgs/<id>/packs/apply` (`pack.apply.console`) hires the pack's
proposed agents in the same act, and its receipt is `{revision, added, pack,
hires}`; when the apply committed but its hire loop did not run, `hires` is
empty and `hireError` names the code, and the card says the hires did not run.
`POST /api/orgs/<id>/packs/hire` with `{pack, project?}`
(`pack.hire.console`) runs the same loop on a pack already applied and answers
`{pack, hires}`; `pack-not-applied` is 404 and `right-required` 403. Each hire
line is `{name, state, decision | code}`, and a `hired` or `awaiting-owner`
line adds `routeFrom: 'chief' | 'assistant'`, whose harness and model the hire
got (the chief of staff's, else the organization assistant's). `GET /api/orgs/<id>/packs` adds, to
each applied entry, `hired` (the agents its hires created) and `open` (each
proposal not hired, with its reason, its state and its decision or code, and
`fromPack: true` on an `awaiting-owner` line this pack's own hire raised). The
packs routes stay the owner's: a member's pack hire is the bus verb's
(`pack.hire.console` needs `org.hire`, and the flagged hires wait for the
owner), but no member page calls it yet.
The pack card says what applying does before the click ("applying is the hire
decision, and approves the flagged and credential lines below"), shows "N
agents hired" and the open proposals with their reasons after it, and offers
"Hire the N proposed agents" for proposals not waiting for the owner, and for
the owner's own `fromPack` lines, which the owner's hire replaces and approves. Apply,
hire and fire dispatch `mosaic-org-changed`, so the Agents page and the
organization page redraw in the same cycle instead of at the next 10-second
poll. Each agent card a pack hire made says "from pack X". The owner's Agents
page offers Fire on each agent but the chief of staff and the assistant, with a confirm step;
Fire sends `{op: 'fire'}` through `/api/decisions/hire/start`, removes the
card at once and leaves a receipt naming the decision.
### Route registration
A module may export `registerRoutes(table)` and be included with one entry in
+2
View File
@@ -165,6 +165,8 @@ const STATUS = {
// Row 155 (#1649): the assistant's settings, seat names and stop. A name in use or no run to stop
// is the user's to resolve by reading again.
'organization-not-assistant': 400, 'organization-definition-refused': 400, 'unknown-model': 400,
// #1873 triage-fence: a template no organization may hold.
'template-system-only': 400,
'name-taken': 409, 'name-is-instance': 400, 'name-is-role': 400, 'not-assistant': 400, 'not-held': 409,
// Row 165 (#1662): role instances. An id already taken is the user's to resolve by reading again.
'organization-instance-exists': 409, 'organization-unknown-instance': 400,
+103 -6
View File
@@ -19,6 +19,10 @@ import { loadSystem, socketPath, orgPaths, REPO, rolesDir } from '../../cli/src/
import { busStatus as orgBusStatus, busRevive as orgBusRevive } from '../../cli/src/org-bus.mjs';
import { listOrgs, resolveOrg } from '../../organization/src/org-registry.mjs';
import { showOrg } from '../../organization/src/org-service.mjs';
import * as orgService from '../../organization/src/org-service.mjs';
import { orgUsesFixture } from '../../cli/src/dev-fixture.mjs';
import { moveFixtureOrg, ownerModelsFrom, readRider } from '../../model-proxy/src/ride.mjs';
import { ownedText } from '../../model-proxy/src/admin.mjs';
import { configDir } from '../../organization/src/organization-config.mjs';
import { loadRootAgents } from '../../organization/src/agent-levels.mjs';
import { organizationWriter } from '../../organization/src/organization.mjs';
@@ -34,10 +38,15 @@ import { isAbsolute, join } from 'node:path';
import { actionTrail } from './action-trail.mjs';
import { reviveBuses } from './bus-revive.mjs';
import { createProxyAdmin, orgCatalogue } from './proxy-admin.mjs';
import { createTriageHost } from './triage-host.mjs';
import { createTriageRoute, triageTokenPattern } from './triage-route.mjs';
import { loadProxy } from '../../model-proxy/src/settings.mjs';
import { composeSnapshot, readSystemConfig, readOrgConfig } from './triage-snapshot.mjs';
import { busesStopped } from '../../cli/src/proxy-admin-host.mjs';
import { agentLevelsWriteRoutes } from './agent-levels-write.mjs';
import { triageRouteRoutes } from './triage-route-http.mjs';
import { RESTART_EXIT } from '../../cli/src/org-console.mjs';
import { ID_PATTERN } from '../../organization/src/vocabulary.mjs';
import { ID_PATTERN, systemOnly } from '../../organization/src/vocabulary.mjs';
import { selectorScope } from '../../organization/src/selector.mjs';
// The bus verifies the Console's exact same-tree script in /proc, whose argv preserves a
// relative shell argument even though Node's process.argv resolves it. Re-exec the same
@@ -202,8 +211,9 @@ try {
// and the preview are reads over requestRead.
templatesWrite: session.user === undefined && sendOn ? templatesCaller(consoleCall({ dataRoot: root, socket: paths.socket, business: id })) : null,
// Starter packs SP6 (#1873): the owner's workflow read, the organization file and its revision as the
// writer reads them (the read `mosaic org workflow set` takes its revision from), and the V2 template names.
workflowsRead: session.user === undefined ? () => ({ ...organizationWriter({ dir: configDir(), rolesDir: rolesDir() }).read(id), templates: templateHashes(rolesDir()).map(t => t.template) }) : null,
// writer reads them (the read `mosaic org workflow set` takes its revision from), and the V2 template names
// less the system-only ones. packs-http's workflowsRead drops them again and is the tested gate.
workflowsRead: session.user === undefined ? () => ({ ...organizationWriter({ dir: configDir(), rolesDir: rolesDir() }).read(id), templates: templateHashes(rolesDir()).map(t => t.template).filter(t => !systemOnly(t)) }) : null,
reads: consoleReads({ root: REPO, queueRoot: options.checkout ?? REPO, system, configDir: configDir(), rolesDir: rolesDir(), business: id, orgRoot: root }),
};
},
@@ -212,6 +222,31 @@ try {
const agentLevels = organizations ? { loadRoot: () => loadRootAgents(configDir(), { rolesDir: rolesDir() }), rolesDir: rolesDir(), ctx: { configDir: configDir(), dataRoot: system.dataRoot, instance } } : null;
// #1873: proxy setup for the instance owner (dev local owner, or the root owner under --sso).
// Instance-wide: one pinned release, one proxy.json, one unit. Each organization uses it (shared).
// #1873 ride-default: each active organization as Ride all reads it, from its file and change log
// (read only) and, through `call`, from its bus as the owner. A file that cannot be read gives
// undefined fields, which Ride all names as unreadable. The change log is read with the writer's
// own check (no symlink, a regular file this user owns, not group or world writable).
const rideRiders = async () => {
const writer = organizationWriter({ dir: configDir(), rolesDir: rolesDir() });
const local = id => readRider({ id, read: () => writer.read(id).document, readLog: () => ownedText(writer.logFile(id), { mask: 0o022 }), isFixture: orgUsesFixture });
const down = async () => { throw Object.assign(new Error('the bus is not reachable'), { code: 'no-bus-host' }); };
// The single-business Console has no bus status here: its organization never reads as stopped.
if (!organizations) return ownerCall && options.business ? [{ ...local(options.business), call: ownerCall }] : [];
const out = [];
for (const org of await listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance })) {
if (org.state !== 'active') continue;
let call = down; try { const paths = orgPaths(org.root); call = busCaller({ dataRoot: org.root, socket: paths.socket, business: org.id, timeoutMs: 5000 }); } catch {}
// The organization admin page's stopped test reads this bus status (its process id).
out.push({ ...local(org.id), call, status: () => orgBusStatus({ configDir: configDir(), dataRoot: system.dataRoot, instance }, org.id) });
}
return out;
};
// The owner's models (ride.mjs ownerModelsFrom): the proxy is set up when proxy.json names a port.
const ownerModels = system && (devOwner || ssoOn) ? async () => {
let proxy = false;
try { proxy = Number.isInteger(loadProxy(configDir(), system.dataRoot)?.port); } catch {}
return ownerModelsFrom({ proxy, riders: proxy ? await rideRiders() : [] });
} : null;
const proxyAdmin = system && (devOwner || ssoOn) ? createProxyAdmin({
dataRoot: system.dataRoot, configDir: configDir(), instance, unitDir: options.proxyUnitDir ?? null,
buses: () => busesStopped({ dataRoot: system.dataRoot, configDir: configDir() }),
@@ -226,21 +261,83 @@ try {
}
return out;
},
riders: rideRiders,
ownerModels,
// A stopped fixture organization moves through the organization service's whole-file update, the
// write `POST /api/orgs/ID/admin` makes, as the signed-in owner. The owner starts its bus after.
move: (id, models, principal) => moveFixtureOrg({ service: orgService, ctx: { configDir: configDir(), dataRoot: system.dataRoot, instance, principal }, id, models }),
}) : null;
// #1873 triage-host: the instance owner's Triage session, hosted by the Console in no organization.
// Nothing starts here; the owner's first message starts it.
// #1873 triage-wiring: the route is resolved at each admit from the route store, the key file, each
// active organization's model catalogue (its bus `routes` verb, as proxy setup reads it) and the
// harness module (triage-route.mjs). The host's fences hold the proxy port and the key's shape.
// The port is read from proxy.json at each admit, so a proxy set up after the Console started counts.
const triageProxyPort = () => {
try { const p = loadProxy(configDir(), system.dataRoot)?.port; return Number.isInteger(p) ? p : null; } catch { return null; }
};
const triageRoute = system && (devOwner || ssoOn) ? createTriageRoute({
dataRoot: system.dataRoot, configDir: configDir(), proxyPort: triageProxyPort,
catalogues: async () => {
// A bus that does not answer gives a catalogue that is not ready, so it confirms nothing.
const read = async call => { try { return (await call('routes'))?.catalogue ?? { status: 'unknown' }; } catch { return { status: 'bus-unavailable' }; } };
if (!organizations) return ownerCall ? [await read(ownerCall)] : [];
const active = (await listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance })).filter(org => org.state === 'active');
return Promise.all(active.map(org => {
let paths; try { paths = orgPaths(org.root); } catch { return { status: 'bus-unavailable' }; }
return read(busCaller({ dataRoot: org.root, socket: paths.socket, business: org.id, timeoutMs: 5000 }));
}));
},
}) : null;
const triage = triageRoute ? createTriageHost({
dataRoot: system.dataRoot, route: triageRoute, proxyPort: triageProxyPort, tokenPattern: triageTokenPattern(configDir()),
devOwner: Boolean(devOwner), log: line => console.log(line),
readSnapshot: () => composeSnapshot({
orgs: () => listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance }),
busStatus: id => orgBusStatus({ configDir: configDir(), dataRoot: system.dataRoot, instance }, id),
processing: async id => {
const org = (await listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance })).find(o => o.id === id);
if (!org) return null;
return busCaller({ dataRoot: org.root, socket: orgPaths(org.root).socket, business: id, timeoutMs: 5000 })('processing.status');
},
orgConfig: id => readOrgConfig(id),
proxy: () => proxyAdmin.status(),
systemConfig: () => readSystemConfig(),
}),
}) : null;
let server, testerServer = null;
// F3: the restart route closes every listener and connection, then exits RESTART_EXIT for the
// supervisor to relaunch. Without --supervised the route answers not-supervised.
const restart = supervised ? () => {
sso?.close(); testerServer?.close();
// The Triage session gets SIGTERM now and SIGKILL before the 2 s exit below.
const triageStopped = triage ? triage.stop({ graceMs: 1500 }) : Promise.resolve();
setTimeout(() => process.exit(RESTART_EXIT), 2000).unref();
server.close(() => process.exit(RESTART_EXIT));
server.close(() => triageStopped.finally(() => process.exit(RESTART_EXIT)));
server.closeAllConnections();
} : null;
const trail = system ? actionTrail(join(system.dataRoot, 'console')) : null;
// #1873 A2: Settings > Agents writes for the root and project levels, beside the levels read.
const agentLevelRoutes = organizations ? [agentLevelsWriteRoutes({ configDir: configDir(), rolesDir: rolesDir(), trail })] : [];
// #1873 triage-settings: Settings > Triage reads and saves the route store for the instance owner.
// The model is checked against the catalogue each active organization's bus answers with, as an
// organization's route change is. Saving starts nothing: the Triage host above reads the store at its
// next admit.
const triageRoutes = system && (devOwner || ssoOn) ? [triageRouteRoutes({
dataRoot: system.dataRoot, log: line => console.log(line),
catalogues: async () => {
const read = async call => { try { return (await call('routes'))?.catalogue ?? { status: 'unknown' }; } catch { return { status: 'bus-unavailable' }; } };
if (!organizations) return ownerCall ? [await read(ownerCall)] : [];
// Every active organization is asked at once, so a hung bus costs one timeout, not one each.
const active = (await listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance })).filter(org => org.state === 'active');
return Promise.all(active.map(org => {
let paths; try { paths = orgPaths(org.root); } catch { return { status: 'bus-unavailable' }; }
return read(busCaller({ dataRoot: org.root, socket: paths.socket, business: org.id, timeoutMs: 5000 }));
}));
},
})] : [];
try {
server = await startServer({ restart, trail, ...(lan ? { host: lan.bind, devAllowHosts: lan.allowHosts } : {}), board: options.board, port: options.port, bus, reads, preview: options.preview, sso, proof, send, settingsWrite, projectFiles, projectFile, libraryFile, libraryStatus, librarySync, libraryRevert, librarySave, projectSave, chat, nameWrite, assistantStop, instancesWrite, routesWrite, agentWrite, proxyCall, proxyAdmin, processing, decisionWrite, requestRead, requestWrite, userOptions, federation: system?.federation ?? null, organizations, agentLevels, routes: agentLevelRoutes, preselect: options.business ?? null });
server = await startServer({ restart, trail, ...(lan ? { host: lan.bind, devAllowHosts: lan.allowHosts } : {}), board: options.board, port: options.port, bus, reads, preview: options.preview, sso, proof, send, settingsWrite, projectFiles, projectFile, libraryFile, libraryStatus, librarySync, libraryRevert, librarySave, projectSave, chat, nameWrite, assistantStop, instancesWrite, routesWrite, agentWrite, proxyCall, proxyAdmin, triage, processing, decisionWrite, requestRead, requestWrite, userOptions, federation: system?.federation ?? null, organizations, agentLevels, ownerModels, rideRemoved: proxyAdmin ? id => proxyAdmin.rideRemoved(id) : null, routes: [...agentLevelRoutes, ...triageRoutes], preselect: options.business ?? null });
} catch (err) { sso?.close(); throw err; }
if (testerSocket) {
const call = busCaller({ dataRoot: system.dataRoot, socket: socketPath(system.dataRoot), business: options.business ?? null, cli: TESTER_CLI });
@@ -277,7 +374,7 @@ try {
// D2 (P0-3): the dev Console reattaches to the buses that still run and brings back the ones its
// unit stop killed. It runs after the Console answers, so a slow bus never delays the page.
if (organizations && trail) reviveBuses({ ctx: { configDir: configDir(), dataRoot: system.dataRoot, instance }, listOrgs, busStatus: orgBusStatus, busRevive: orgBusRevive, trail, log: line => console.log(line) }).catch(() => console.log('bus revive: stopped on an unexpected error'));
for (const signal of ['SIGINT', 'SIGTERM']) process.once(signal, () => { sso?.close(); server.close(); testerServer?.close(); });
for (const signal of ['SIGINT', 'SIGTERM']) process.once(signal, () => { sso?.close(); server.close(); testerServer?.close(); triage?.stop(); });
} catch (err) {
console.error(`refused: ${err.message}`);
process.exitCode = 2;
+1
View File
@@ -67,6 +67,7 @@ const HIRE_START_REFUSALS = {
'unknown-model': [409, 'This model is not one of the organization\'s models. Pick a model listed under Settings > Model proxy.' + NONE],
'harness-off': [409, 'This harness is not switched on for the organization. Pick a harness listed under Settings > Routing, or ask the owner to switch it on.' + NONE],
'harness-refused': [409, 'The harness refused this route. Clear Thinking, or pick another model or harness under Settings > Routing.' + NONE],
'template-system-only': [409, 'This role template is for the system, not for an organization. Pick another template.' + NONE],
'definition-not-hireable': [409, 'This organization does not hire agents from this role template. Pick another template.' + NONE],
'definition-shared': [409, 'Another agent uses the same role definition, so this change cannot replace it.' + NONE],
'definition-rev-conflict': [409, 'The role definition changed since it was read. Reload the page and propose again.' + EITHER],
+54 -18
View File
@@ -27,6 +27,7 @@
// handler returns false for them.
import { open } from 'node:fs/promises';
import { pickModel, usableModel } from '../../model-proxy/src/ride.mjs';
import { lstatSync } from 'node:fs';
import { checkProject, initProject, projectRepo, recordContext } from '../../project/src/index.mjs';
import { refuseInsideAgent } from '../../cli/src/transport.mjs';
@@ -285,33 +286,53 @@ function refusal(res, error, { step, id, unknownOk = false }) {
// Default service wiring: the real C1/C2/C3 modules, loaded on first use.
// A missing module (a branch without S1 yet) answers not-configured.
async function load(spec) { try { return await import(spec); } catch (e) { if (e?.code === 'ERR_MODULE_NOT_FOUND') return null; throw e; } }
export function defaultOrgAdmin(env = process.env) {
export function defaultOrgAdmin(env = process.env, { ownerModels = null, rideRemoved = null } = {}) {
let system = null;
// The same context `mosaic org` builds (packages/cli/src/org.mjs): the named
// instance from MOSAIC_CONFIG, its data root and its config directory.
const context = async () => {
if (!system) {
const { loadSystem } = await import('../../cli/src/config.mjs');
const { configDir } = await import('../../organization/src/organization-config.mjs');
const { devOwnerInstance } = await import('../../cli/src/dev-local-owner.mjs');
let instance; try { instance = devOwnerInstance(env); } catch { return null; }
system = { configDir: configDir(env), dataRoot: loadSystem({ env, instance }).dataRoot, instance };
}
return system;
};
return createOrgAdmin({
ownerModels, rideRemoved: rideRemoved ?? removalRecorder(context),
service: () => load('../../organization/src/org-service.mjs'),
registry: () => load('../../organization/src/org-registry.mjs'),
bus: () => load('../../cli/src/org-bus.mjs'),
// The same context `mosaic org` builds (packages/cli/src/org.mjs): the named
// instance from MOSAIC_CONFIG, its data root and its config directory.
context: async () => {
if (!system) {
const { loadSystem } = await import('../../cli/src/config.mjs');
const { configDir } = await import('../../organization/src/organization-config.mjs');
const { devOwnerInstance } = await import('../../cli/src/dev-local-owner.mjs');
let instance; try { instance = devOwnerInstance(env); } catch { return null; }
system = { configDir: configDir(env), dataRoot: loadSystem({ env, instance }).dataRoot, instance };
}
return system;
},
context,
});
}
// A Console without the proxy setup page still records a removal of cliproxy, in the instance's
// proxy receipts (model-proxy admin.mjs appendReceipt), where Ride all reads it. `context()` gives
// the instance's data root; with none, the record and the save are refused.
export function removalRecorder(context) {
return async id => {
const ctx = await context(), proxy = await load('../../model-proxy/src/admin.mjs');
if (!ctx?.dataRoot || !proxy) throw Object.assign(new Error('not-configured'), { code: 'not-configured' });
return proxy.appendReceipt(ctx.dataRoot, { time: new Date().toISOString(), op: 'ride-removed', org: id });
};
}
// `service`, `registry` and `bus` are module objects or functions returning
// them (or null when absent). `context()` gives { configDir, dataRoot, instance }.
export function createOrgAdmin({ service, registry = null, bus = null, context }) {
// `ownerModels()` (#1873 ride-default) answers {proxy, riding, models} from the owner's model
// proxy, read through the riding buses; without it the cliproxy preset reads unavailable.
// `rideRemoved(id)` records in the proxy's receipts that a save took cliproxy off the organization,
// so Ride all leaves it off; without it such a save is refused.
export function createOrgAdmin({ service, registry = null, bus = null, context, ownerModels = null, rideRemoved = null }) {
const get = async x => (typeof x === 'function' ? x() : x);
return { service: () => get(service), registry: () => get(registry), bus: () => get(bus), context: () => get(context) };
const owner = async () => { if (typeof ownerModels !== 'function') return { proxy: false, riding: false, models: [] }; try { return await ownerModels(); } catch { return { proxy: false, riding: false, models: [] }; } };
return { service: () => get(service), registry: () => get(registry), bus: () => get(bus), context: () => get(context), ownerModels: owner, rideRemoved };
}
const providersOf = doc => (Array.isArray(doc?.plugins?.['model-provider']) ? doc.plugins['model-provider'] : []);
const ownerOf = admin => (typeof admin.ownerModels === 'function' ? admin.ownerModels() : { proxy: false, riding: false, models: [] });
// The handler. Returns true when it answered. `owner` is the signed-in owner
// session (provider, iss, sub) or null; `send` says --send is on; `origin` is
@@ -413,17 +434,26 @@ async function route(req, res, { path, search, org, admin, principal, write, log
if (path === '/api/org-presets' && !write) {
if (new URLSearchParams(search).size) return json(res, 422, { error: 'invalid', message: 'unexpected query parameter' });
const service = await need(admin, 'service', res, 'presets'); if (!service) return;
try { return json(res, 200, { presets: await service.orgPresets() }); }
try { return json(res, 200, { presets: await service.orgPresets({ owner: await ownerOf(admin) }) }); }
catch (e) { return refusal(res, e, { step: 'presets' }); }
}
if (path === '/api/org-template' && !write) {
const params = new URLSearchParams(search);
for (const [key] of params) if (!['id', 'preset', 'thinking'].includes(key) || params.getAll(key).length !== 1) return json(res, 422, { error: 'invalid', message: 'invalid template query' });
for (const [key] of params) if (!['id', 'preset', 'thinking', 'model'].includes(key) || params.getAll(key).length !== 1) return json(res, 422, { error: 'invalid', message: 'invalid template query' });
if (params.has('model') && params.get('preset') !== 'cliproxy') return json(res, 422, { error: 'invalid', message: 'model applies to the cliproxy preset only' });
const id = params.has('id') ? params.get('id') : 'new-org';
if (!ID.test(id)) return json(res, 422, { error: 'invalid', errors: [{ path: '$.id', field: 'id', message: 'invalid organization id' }] });
const service = await need(admin, 'service', res, 'template'); if (!service) return;
// #1873 ride-default: the cliproxy preset routes to a model the owner's catalogue lists. A named
// model must be one of them; otherwise the Console picks one (claude first).
let model;
if (params.get('preset') === 'cliproxy') {
const owner = await ownerOf(admin), models = Array.isArray(owner?.models) ? owner.models : [];
model = params.has('model') ? models.find(m => usableModel(m) && m.key === params.get('model')) : (owner?.proxy === true && owner?.riding === true ? pickModel(models) : null);
if (!model) return json(res, 422, { error: 'invalid', step: 'template', errors: [{ path: '$.model', field: 'model', message: params.has('model') ? 'the model proxy lists no such model' : 'the model proxy lists no model you can use' }] });
}
let doc;
try { doc = await service.templateRender(id, params.has('preset') || params.has('thinking') ? { ...(params.has('preset') ? { preset: params.get('preset') } : {}), ...(params.has('thinking') ? { thinking: params.get('thinking') } : {}) } : { fixture: 'local' }); } catch (e) { return refusal(res, e, { step: 'template' }); }
try { doc = await service.templateRender(id, params.has('preset') || params.has('thinking') ? { ...(params.has('preset') ? { preset: params.get('preset') } : {}), ...(params.has('thinking') ? { thinking: params.get('thinking') } : {}), ...(model ? { model } : {}) } : { fixture: 'local' }); } catch (e) { return refusal(res, e, { step: 'template' }); }
const shown = forBrowser(doc);
return json(res, 200, { id, doc: shown.doc, held: shown.held, verb: verbFor('create', id) });
}
@@ -509,6 +539,12 @@ async function route(req, res, { path, search, org, admin, principal, write, log
const doc = toCanonical(id, body.doc, shown.doc);
const checked = await service.validateOrg(doc);
if (!checked.ok) return json(res, 422, { error: 'invalid', step: 'update', errors: withField(checked.errors ?? []) });
// #1873 ride-default: a save that takes cliproxy off leaves a proxy receipt first, so Ride all
// does not put it back. No record, no save.
if (providersOf(shown.doc).includes('cliproxy') && !providersOf(doc).includes('cliproxy')) {
if (typeof admin.rideRemoved !== 'function') return json(res, 503, { error: 'not-configured', step: 'update', message: 'this Console cannot record that the model proxy was taken off, so nothing was saved' });
try { await admin.rideRemoved(id); } catch { return json(res, 500, { error: 'internal', step: 'update', message: 'the removal of the model proxy could not be recorded, so nothing was saved' }); }
}
let receipt;
try { receipt = await service.updateOrg(ctx, id, doc, { ifRevision: body.ifRevision }); } catch (e) { return refusal(res, e, { step: 'update', id, unknownOk: true }); }
return json(res, 200, { outcome: 'done', step: 'update', receipt: forReceipt(ctx, receipt), verb: verbFor('update', id, { revision: body.ifRevision }) });
+34 -14
View File
@@ -2,10 +2,14 @@
// selected organization. Owner Console transports only; no caller-supplied business, actor, subject
// or origin reaches the bus.
//
// GET /api/orgs/<id>/packs {packs, writable}: packs.console, the shipped and installed
// packs (never a saved template). /api/packs on a root Console.
// GET /api/orgs/<id>/packs {packs, applied, writable}: packs.console, the shipped and installed
// packs (never a saved template), and each applied entry with the
// agents its hires created and its open proposals. /api/packs on a root Console.
// POST /api/orgs/<id>/packs/preview {pack, project?, as?}: pack.preview.console. Writes nothing.
// POST /api/orgs/<id>/packs/apply {pack, digest, project?, as?}: pack.apply.console
// POST /api/orgs/<id>/packs/apply {pack, digest, project?, as?}: pack.apply.console. Ruling 2026-11-14:
// the owner's apply is the hire decision; the receipt carries `hires`
// POST /api/orgs/<id>/packs/hire {pack, project?}: pack.hire.console, the proposals of a pack already
// applied, hired through the same loop. {pack, hires}
// POST /api/orgs/<id>/board {revision, board, project?}: board.set.console (board null removes it)
// POST /api/orgs/<id>/workflows/<name> {revision, workflow, project?}: workflow.set.console
// DELETE /api/orgs/<id>/workflows/<name> {revision, project?}: workflow.set.console with workflow null
@@ -15,17 +19,19 @@
// file revision a workflow write sends back
//
// `read` is the owner's Console call (consoleCall), used for the two verbs that write nothing. `write`
// is the owner's Console call fenced to the three write verbs (packsCaller), present only for the
// is the owner's Console call fenced to the four write verbs (packsCaller), present only for the
// owner's own session under --send. The broker answers every .console verb to the business human's
// console cap alone, and runs the merge, the digest and the held-credential check itself. `workflows`
// (SP6) is the owner's read of the organization file as the writer reads it ({document, revision,
// templates}), the same read `mosaic org workflow set` takes its revision from; no bus verb answers it.
export const PACKS_ROUTE = /^\/api\/(?:packs(?:\/(preview|apply))?|board|workflows(?:\/([^/]+))?)$/;
import { systemOnly } from '../../organization/src/vocabulary.mjs';
export const PACKS_ROUTE = /^\/api\/(?:packs(?:\/(preview|apply|hire))?|board|workflows(?:\/([^/]+))?)$/;
// Which requests the pack route answers. GET and HEAD /api/board stay the Board read (the Console's own task
// board through its upstream); every other method on /api/board is this route's (POST writes, the rest 405).
// serve.mjs dispatches on this, so the HEAD pin in packs-http.test.mjs tests the predicate it uses.
export const packsServes = (path, method) => PACKS_ROUTE.test(path) && !(path === '/api/board' && (method === 'GET' || method === 'HEAD'));
export const PACK_WRITE_VERBS = Object.freeze(['pack.apply.console', 'board.set.console', 'workflow.set.console']);
export const PACK_WRITE_VERBS = Object.freeze(['pack.apply.console', 'pack.hire.console', 'board.set.console', 'workflow.set.console']);
export const packsCaller = call => async (verb, args, options) => {
if (!PACK_WRITE_VERBS.includes(verb)) throw new Error(`the pack writer does not call ${verb}`);
return call(verb, args, options);
@@ -37,10 +43,10 @@ const REVISION = /^[a-f0-9]{64}$/;
// A board or workflow body stays small; the organization config caps both (WORKFLOWS_MAX, board columns).
const LIMIT = 65536;
const codes = {
'invalid-request': 400, 'credential-leak': 400, 'starter-pack-invalid': 400, 'definition-invalid': 400,
'starter-pack-not-found': 404, 'project-not-found': 404,
'invalid-request': 400, 'credential-leak': 400, 'starter-pack-invalid': 400, 'definition-invalid': 400, 'template-system-only': 400,
'starter-pack-not-found': 404, 'project-not-found': 404, 'pack-not-applied': 404,
'pack-plan-stale': 409, 'revision-conflict': 409, 'organization-busy': 409,
'human-required': 403, 'read-only': 403,
'human-required': 403, 'read-only': 403, 'right-required': 403,
'not-configured': 503, 'no-bus-host': 503,
};
const one = (req, key) => req.headersDistinct[key]?.length === 1 ? req.headersDistinct[key][0] : null;
@@ -89,7 +95,7 @@ export async function packsHTTP(req, res, { path, owner, read, write, workflows
let verb, args = {};
if (list) verb = 'packs.console';
else if (step !== null) {
const value = await body(req, step === 'apply' ? ['pack', 'digest'] : ['pack'], ['project', 'as']);
const value = await body(req, step === 'apply' ? ['pack', 'digest'] : ['pack'], step === 'hire' ? ['project'] : ['project', 'as']);
if (value === 'too-large') return refuse(413, 'invalid-request');
if (!value || typeof value.pack !== 'string' || !(NAME.test(value.pack) || SAVED.test(value.pack))
|| (step === 'apply' && (typeof value.digest !== 'string' || !REVISION.test(value.digest)))
@@ -124,16 +130,29 @@ export async function packsHTTP(req, res, { path, owner, read, write, workflows
if (!plain(result)) return refuse(503, 'outcome-unknown');
if (list) {
if (!Array.isArray(result.packs)) return refuse(503, 'outcome-unknown');
return json(res, 200, { packs: result.packs, writable: Boolean(write) });
const applied = Array.isArray(result.applied) ? result.applied.filter(plain).map(a => ({ id: a.id, origin: a.origin ?? null, project: a.project ?? null,
hired: Array.isArray(a.hired) ? a.hired.filter(n => typeof n === 'string') : [],
open: Array.isArray(a.open) ? a.open.filter(plain).map(o => ({ name: o.name, reason: typeof o.reason === 'string' ? o.reason : '', state: o.state, ...(typeof o.code === 'string' ? { code: o.code } : {}), ...(typeof o.decision === 'string' ? { decision: o.decision } : {}), ...(o.fromPack === true ? { fromPack: true } : {}) })) : [] })) : [];
return json(res, 200, { packs: result.packs, applied, writable: Boolean(write) });
}
if (step === 'preview') {
if (!REVISION.test(result.digest ?? '')) return refuse(503, 'outcome-unknown');
return json(res, 200, result);
}
// A write admitted may already have committed: its receipt is returned even if the session ended
// meanwhile, never reported as not done.
// meanwhile, never reported as not done. Each hire line is its name, state and decision or code,
// and for a raised hire routeFrom, whose harness and model it got (lane pr2).
const hires = Array.isArray(result.hires) ? result.hires.filter(plain).map(h => ({ name: h.name, state: h.state,
...(typeof h.decision === 'string' ? { decision: h.decision } : {}), ...(typeof h.code === 'string' ? { code: h.code } : {}),
...(['chief', 'assistant'].includes(h.routeFrom) ? { routeFrom: h.routeFrom } : {}) })) : null;
if (step === 'hire') {
if (!hires) return refuse(503, 'outcome-unknown');
return json(res, 200, { pack: result.pack, hires });
}
if (!REVISION.test(result.revision ?? '')) return refuse(503, 'outcome-unknown');
return json(res, 200, { revision: result.revision, added: Array.isArray(result.added) ? result.added : [], ...(step === 'apply' ? { pack: result.pack } : {}) });
// hireError: the apply committed but its hire loop did not run (organization-busy, outcome-unknown).
const hireError = step === 'apply' && typeof result.hireError === 'string' && /^[a-z0-9-]{1,64}$/.test(result.hireError) ? { hireError: result.hireError } : {};
return json(res, 200, { revision: result.revision, added: Array.isArray(result.added) ? result.added : [], ...(step === 'apply' ? { pack: result.pack, hires: hires ?? [], ...hireError } : {}) });
}
// SP6: the workflow list and editor's read. Only workflows, the names a step role may resolve to and the
@@ -154,7 +173,8 @@ async function workflowsRead(res, { workflows, live, session, writable }) {
}
const roles = {
definitions: Object.keys(plain(doc.definitions) ? doc.definitions : {}).sort(),
templates: current.templates.filter(n => typeof n === 'string').sort(),
// #1873 triage-followups: a system-only template (organization vocabulary SYSTEM_ONLY) is never offered.
templates: current.templates.filter(n => typeof n === 'string' && !systemOnly(n)).sort(),
};
return json(res, 200, { workflows: flowsOf(doc), projects, roles, revision: current.revision, writable });
}
+9 -1
View File
@@ -28,6 +28,9 @@ const ROUTES = Object.freeze({
'/api/proxy/admin/unit/restart': ['POST', []],
'/api/proxy/admin/fence/clear': ['POST', []],
'/api/proxy/admin/init-lock/clear': ['POST', []],
// #1873 ride-default: Ride all, and the confirmed move of one stopped fixture organization.
'/api/proxy/admin/ride-all': ['POST', []],
'/api/proxy/admin/ride-move': ['POST', ['org']],
});
export const PROXY_ADMIN_PATHS = Object.freeze(Object.keys(ROUTES));
const INIT_KEYS = ['generate', 'key', 'confirm', 'port', 'rotateGraceMinutes', 'firstOutputSeconds'];
@@ -46,7 +49,8 @@ const STATUS = { 'human-required': 403, 'proxy-key-transport': 403, 'not-configu
// `owner` is true only for the instance owner's session (the dev local owner, or the root owner
// signed in under --sso). `call` is the owner's transport to the selected bus, or null.
export async function proxyAdminHTTP(req, res, { path, admin, call, named, tester, granted, owner, send, origin, user, log }) {
// `principal` is that session's {provider, iss, sub}; the organization service checks it again.
export async function proxyAdminHTTP(req, res, { path, admin, call, named, tester, granted, owner, send, origin, user, principal = null, log }) {
const route = ROUTES[path];
const done = (status, value) => {
// Path, method and status only: never a body, key, evidence or exception text.
@@ -105,6 +109,10 @@ export async function proxyAdminHTTP(req, res, { path, admin, call, named, teste
if (!call) return refuse('not-configured');
return done(200, await admin.fenceClear(call));
case '/api/proxy/admin/init-lock/clear': return done(200, await admin.initLockClear());
case '/api/proxy/admin/ride-all': return done(200, await admin.rideAll());
case '/api/proxy/admin/ride-move':
if (typeof args.org !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(args.org)) return refuse('invalid-request');
return done(200, await admin.rideMove({ org: args.org, principal }));
}
} catch (error) {
const code = ['human-required', 'not-configured', 'invalid-request'].includes(error?.code) ? error.code : proxyCode(error, 'outcome-unknown');
+3 -1
View File
@@ -51,6 +51,8 @@ export async function proxyHTTP(req, res, { path, call, named, tester, granted,
try { return done(200, await call(route[1], args)); }
catch (error) {
const code = codes.includes(error.code) || (path === '/api/proxy/plugins/set' && typeof error.code === 'string' && /^[a-z-]{1,64}$/.test(error.code)) ? error.code : 'outcome-unknown';
return done(code === 'human-required' ? 403 : ['not-configured', 'proxy-down', 'outcome-unknown'].includes(code) ? 503 : 400, { error: code });
// proxy-pickup (#1873): a bus with no proxy client names the cause in one plain line.
const reason = code === 'not-configured' && typeof error.reason === 'string' ? { reason: error.reason.slice(0, 300) } : {};
return done(code === 'human-required' ? 403 : ['not-configured', 'proxy-down', 'outcome-unknown'].includes(code) ? 503 : 400, { error: code, ...reason });
}
}
+57 -30
View File
@@ -76,8 +76,11 @@
if (!usable() || busy || pending || !view) return;
const [url, payload] = plan(action, name);
busy = true; confirming = null; receipt = ''; redraw();
const gen = generation;
let answer;
try { answer = await post(url, payload); } catch { answer = { ok: false, result: { sent: 'unknown' } }; }
// #1873 SP1: an organization switch while this was in flight drops the answer; the switch already cleared busy.
if (gen !== generation) return;
busy = false;
if (answer === null) return;
const { ok, result } = answer;
@@ -122,8 +125,10 @@
const instance = create.instance.trim(), definition = create.definition;
if (!instance || !definition) { receipt = 'Name the instance and choose a definition.'; redraw(); return; }
busy = true; receipt = ''; redraw();
const gen = generation;
let answer;
try { answer = await post('/api/instances', { revision: view.revision, instance, op: 'add', definition }); } catch { answer = { ok: false, result: { sent: 'unknown' } }; }
if (gen !== generation) return;
busy = false;
if (answer === null) return;
if (answer.ok && /^[a-f0-9]{64}$/.test(answer.result?.revision ?? '')) { create = { instance: '', definition: '' }; receipt = `Created ${instance}. ${answer.result.restart ? restartText() : NO_RESTART_TEXT}`; reread(); }
@@ -154,19 +159,31 @@
document.addEventListener('submit', e => { if (e.target?.id !== 'agent-create-form') return; e.preventDefault(); createAgent(); });
// A sign-out stops any poll; nothing that was asked is retried.
document.addEventListener('mosaic-signed-out', () => { generation++; pending = null; confirming = null; });
// #1873 SP1: opening another organization stops any poll and clears what this section held for the
// old one. A request already sent finishes on the old organization's bus; its page reads it again there.
document.addEventListener('mosaic-org-switch', () => {
generation++; pending = null; receipt = ''; editing = null; confirming = null; busy = false;
create = { instance: '', definition: '' };
for (const k of Object.keys(reasons)) delete reasons[k];
});
// F3: restart an agent so a route change reaches it now, offered by the Routing receipt. One
// terminate; then reads of the instances until the run has left (up to the 60 s regenerate
// allows); then one launch. A thread definition is not launched: its next message starts it.
// A refusal, a sign-out or an unknown outcome stops the chain and says so; nothing is retried.
const restarts = Object.create(null);
let restarts = Object.create(null);
// #1873 SP1: the chain's reads and writes go to the organization it started in, which the fetch
// wrapper passes through unchanged. A switch clears what the new page shows; the old chain keeps
// its own entry and stops painting.
const pin = (org, path) => org ? `/api/orgs/${encodeURIComponent(org)}/${path.slice('/api/'.length)}` : path;
document.addEventListener('mosaic-org-switch', () => { restarts = Object.create(null); });
const RESTART_WAIT = 30;
function restartMarkup(name, thread = false) {
const r = restarts[name];
return `<span class="agent-restart"><button type="button" class="btn" data-agent-restart="${esc(name)}" data-agent-thread="${thread ? 'yes' : 'no'}"${r?.busy ? ' disabled' : ''}>${r?.busy ? 'Restarting…' : `Restart ${esc(name)} now`}</button> <span role="status" data-agent-restart-status="${esc(name)}">${esc(r?.text ?? '')}</span></span>`;
}
const esc = s => String(s).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
const paintRestart = name => document.querySelectorAll('.agent-restart').forEach(el => {
const paintRestart = (name, org = window.MosaicOrg?.id ?? null) => (window.MosaicOrg?.id ?? null) !== org ? undefined : document.querySelectorAll('.agent-restart').forEach(el => {
const b = el.querySelector('[data-agent-restart]');
if (b?.dataset.agentRestart === name) el.outerHTML = restartMarkup(name, b.dataset.agentThread === 'yes');
});
@@ -176,51 +193,61 @@
catch { return { unknown: true }; }
if (res.type === 'opaqueredirect') return { signedOut: true };
try { result = await res.json(); } catch { return { unknown: true }; }
return { ok: res.ok, result };
return { ok: res.ok, status: res.status, result };
}
// The request's closing read, or a reason the chain stops.
async function closing(request) {
async function closing(request, org) {
for (let tries = 0; tries < POLL_LIMIT; tries++) {
await new Promise(r => setTimeout(r, POLL_MS));
let res, r = null;
try { res = await fetch(`/api/agent/request?id=${encodeURIComponent(request)}`, { cache: 'no-store', redirect: 'manual' }); } catch { continue; }
try { res = await fetch(pin(org, `/api/agent/request?id=${encodeURIComponent(request)}`), { cache: 'no-store', redirect: 'manual' }); } catch { continue; }
if (res.type === 'opaqueredirect') return { stop: 'Sign in again, then read the agents.' };
try { r = await res.json(); } catch { continue; }
if (res.ok && r?.request === request && r.state === 'closed') return { done: r };
}
return { stop: `Request ${request} is still open. Read the agents again later.` };
}
async function runs(name) {
async function runs(name, org) {
try {
const res = await fetch('/api/bus/instances', { cache: 'no-store', redirect: 'manual' });
const res = await fetch(pin(org, '/api/bus/instances'), { cache: 'no-store', redirect: 'manual' });
if (!res.ok || res.type === 'opaqueredirect') return null;
const e = (await res.json())?.rows?.[0]?.instances?.[name];
return e ? (Array.isArray(e.running) ? e.running.length : 0) : 0;
} catch { return null; }
}
async function restartAgent(name, thread) {
const r = restarts[name] = { busy: true, text: `Terminating ${name}…` };
const stop = text => { r.busy = false; r.text = text; paintRestart(name); };
paintRestart(name);
const asked = await send('/api/agent/terminate', { instance: name, reason: 'route change' });
if (asked.signedOut) return stop('Sign in again, then retry.');
if (asked.unknown || !asked.ok || !REQUEST_ID.test(asked.result?.request ?? '')) return stop(asked.ok || asked.unknown ? UNKNOWN : refused(asked.result));
const ended = await closing(asked.result.request);
if (ended.stop) return stop(ended.stop);
if (ended.done.reason) return stop(`${name}: ${ended.done.reason}. It was not restarted.`);
r.text = `Terminated ${name}. Waiting for its session to end…`; paintRestart(name);
// SP19 (#1873): the agent drawer's Restart runs this same chain. `org` is the agent's own organization
// (on #/agents the page has none), `reason` goes with the terminate, `text(step, detail)` may give the
// words for a step (nothing keeps the route-change words below), and `onStatus({ step, busy, text })`
// takes each line in place of the Routing receipt's button. The chain never regenerates.
async function restartAgent(name, thread, { org = window.MosaicOrg?.id ?? null, reason = 'route change', text, onStatus } = {}) {
const r = { busy: true, text: '' };
if (!onStatus) restarts[name] = r;
const paint = step => onStatus ? onStatus({ step, busy: r.busy, text: r.text }) : paintRestart(name, org);
const words = (step, detail, own) => (typeof text === 'function' ? text(step, detail) : undefined) ?? own;
const say = (step, detail, own) => { r.text = words(step, detail, own); paint(step); };
const stop = (step, detail, own) => { r.busy = false; say(step, detail, own); };
say('ending', {}, `Terminating ${name}…`);
const asked = await send(pin(org, '/api/agent/terminate'), { instance: name, reason });
if (asked.signedOut) return stop('signedOut', {}, 'Sign in again, then retry.');
if (asked.unknown || !asked.ok || !REQUEST_ID.test(asked.result?.request ?? '')) return asked.ok || asked.unknown ? stop('endUnknown', {}, UNKNOWN) : stop('endRefused', { status: asked.status, result: asked.result }, refused(asked.result));
const ended = await closing(asked.result.request, org);
if (ended.stop) return stop('endOpen', { stop: ended.stop }, ended.stop);
if (ended.done.reason) return stop('endClosed', { reason: ended.done.reason }, `${name}: ${ended.done.reason}. It was not restarted.`);
say('ended', {}, `Terminated ${name}. Waiting for its session to end…`);
let left = false;
for (let i = 0; i < RESTART_WAIT && !left; i++) { await new Promise(res => setTimeout(res, POLL_MS)); left = (await runs(name)) === 0; }
if (!left) return stop(`${name} was asked to end but its session is still running. Launch it from Agents once it has ended.`);
if (thread) return stop(`Terminated ${name} at ${new Date().toLocaleTimeString()}. Its next message starts it on the new route.`);
r.text = `Launching ${name}…`; paintRestart(name);
const launch = await send('/api/agent/launch', { instance: name });
if (launch.signedOut) return stop('Sign in again. It was terminated and not launched.');
if (launch.unknown || !launch.ok || !REQUEST_ID.test(launch.result?.request ?? '')) return stop(launch.ok || launch.unknown ? `${UNKNOWN} It was terminated.` : `${refused(launch.result)} It was terminated and not launched.`);
const started = await closing(launch.result.request);
if (started.stop) return stop(started.stop);
if (started.done.reason) return stop(`${name}: ${started.done.reason}. It was terminated and not launched.`);
return stop(`Restarted ${name} on the new route${started.done.done?.run ? ` (run ${started.done.done.run})` : ''}.`);
for (let i = 0; i < RESTART_WAIT && !left; i++) { await new Promise(res => setTimeout(res, POLL_MS)); left = (await runs(name, org)) === 0; }
if (!left) return stop('stillRunning', {}, `${name} was asked to end but its session is still running. Launch it from Agents once it has ended.`);
const time = new Date().toLocaleTimeString();
if (thread) return stop('threadEnded', { time }, `Terminated ${name} at ${time}. Its next message starts it on the new route.`);
say('launching', {}, `Launching ${name}…`);
const launch = await send(pin(org, '/api/agent/launch'), { instance: name });
if (launch.signedOut) return stop('launchSignedOut', {}, 'Sign in again. It was terminated and not launched.');
if (launch.unknown || !launch.ok || !REQUEST_ID.test(launch.result?.request ?? '')) return launch.ok || launch.unknown ? stop('launchUnknown', {}, `${UNKNOWN} It was terminated.`) : stop('launchRefused', { status: launch.status, result: launch.result }, `${refused(launch.result)} It was terminated and not launched.`);
const started = await closing(launch.result.request, org);
if (started.stop) return stop('launchOpen', { stop: started.stop }, started.stop);
if (started.done.reason) return stop('launchClosed', { reason: started.done.reason }, `${name}: ${started.done.reason}. It was terminated and not launched.`);
const run = started.done.done?.run ?? null;
return stop('restarted', { run }, `Restarted ${name} on the new route${run ? ` (run ${run})` : ''}.`);
}
document.addEventListener('click', e => {
const b = e.target.closest?.('[data-agent-restart]');
@@ -228,7 +255,7 @@
restartAgent(b.dataset.agentRestart, b.dataset.agentThread === 'yes');
});
window.MosaicAgents = Object.freeze({ section, restartMarkup, isThread: definition => threadDefinitions.has(definition) });
window.MosaicAgents = Object.freeze({ section, restartMarkup, restart: restartAgent, isThread: definition => threadDefinitions.has(definition) });
})();
/* #1873 A2: Settings > Agents, the root and project agent levels. bus.js awaits section() for the
+64 -18
View File
@@ -11,8 +11,10 @@
// Show machine sessions (#1589): off by default, kept with the page's settings. While it is off the
// page doesn't read /api/board at all; the held roles above come from the bus (bus.js).
let machine = false;
const boardKey = window.MosaicOrg ? `mosaic-console-board:${window.MosaicOrg.id}` : 'mosaic-console-board';
try { machine = JSON.parse(localStorage.getItem(boardKey))?.machine === true; } catch {}
// #1873 SP1: kept per organization, read again when the open organization changes.
const boardKey = () => window.MosaicOrg?.id ? `mosaic-console-board:${window.MosaicOrg.id}` : 'mosaic-console-board';
const readMachine = () => { try { return JSON.parse(localStorage.getItem(boardKey()))?.machine === true; } catch { return false; } };
machine = readMachine();
// Signed out (#1589): a Console fetch answered with a redirect, so the sign-in proxy turned it away.
// The first one sets body.signed-out (the listener below); after that no Console fetch is made.
const out = () => document.body.classList.contains('signed-out');
@@ -58,6 +60,11 @@
const darkPreference = window.matchMedia('(prefers-color-scheme: dark)');
const APPEARANCE_KEY = 'mosaic-console-appearance', LAST_KEY = 'mosaic-console-appearance-last';
const orgKey = id => `${APPEARANCE_KEY}:${id}`;
// #1873 SP2: the system dashboard is no organization's page. It shows the system theme: this browser's
// own choice made there, else the default, never the theme of the organization opened last.
const SYSTEM_KEY = 'mosaic-console-appearance-system';
// SP3: display.js owns which addresses are system pages (the dashboard and #/inbox); the bare address is one before it normalizes.
const onSystem = () => !!window.MosaicOrg && ((!/^#\/orgs\//.test(location.hash) && ['', '/'].includes(location.hash.replace(/^#/, '').split('?')[0])) || window.MosaicOrg.system?.() === true);
const store = {
read(k) { try { const v = JSON.parse(localStorage.getItem(k)); return v && typeof v === 'object' && !Array.isArray(v) ? v : null; } catch { return null; } },
write(k, v) { try { localStorage.setItem(k, JSON.stringify(v)); return true; } catch { return false; } },
@@ -66,7 +73,10 @@
const orgId = v => typeof v === 'string' && v.length > 0 && v.length <= 64;
// org: null until the Console knows which organization it shows. Then the override lives under that organization's own key;
// before that, and for a Console with no organization, it is the browser-wide record this page has always kept.
let org = null, override = null, themes = null, themesUnavailable = false, current = null, applied = [];
let org = null, override = null, themes = null, themesUnavailable = false, current = null, applied = [], system = false;
const shown = () => (system ? null : org);
// Kept in memory too: a choice storage refused still shows until reload, as an organization's does.
let systemOverride = Brand.appearanceOf(store.read(SYSTEM_KEY));
const readOverride = () => {
if (org) return Brand.appearanceOf(store.read(orgKey(org.id)));
const v = store.read(APPEARANCE_KEY);
@@ -78,7 +88,7 @@
$('theme-switch').setAttribute('aria-checked', String(dark));
}
function paintNotices() {
const w = current.warning, banner = $('theme-warning'), cue = $('org-cue'), label = org?.label;
const w = current.warning, banner = $('theme-warning'), cue = $('org-cue'), label = shown()?.label;
banner.hidden = !w;
if (w) {
const asked = String(w.theme).slice(0, 64), kept = w.source === 'browser' ? 'The choice is kept.' : 'The saved value is unchanged.';
@@ -91,11 +101,12 @@
$('theme-clear').textContent = label ? `Use ${label}’s theme` : 'Use the default theme';
}
// Colour is never the only cue to which organization this is: whenever the theme is not the built-in one, the name is written out.
cue.hidden = !(org && (current.theme !== Brand.DEFAULT_THEME || w));
cue.hidden = !(shown() && (current.theme !== Brand.DEFAULT_THEME || w));
if (!cue.hidden) cue.textContent = w ? `${label} · Harbor shown instead of “${String(w.theme).slice(0, 64)}”` : `${label} · ${nameOf(current.theme)} theme · ${current.themeSource === 'browser' ? 'your choice in this browser' : 'set by the organization'}`;
}
function paint() {
current = Brand.resolveAppearance({ themes, unavailable: themesUnavailable, saved: org?.saved ?? null, override });
system = onSystem();
current = Brand.resolveAppearance({ themes, unavailable: themesUnavailable, saved: shown()?.saved ?? null, override: system ? systemOverride : override });
const root = document.documentElement;
root.dataset.palette = current.theme;
if (current.mode === 'system') delete root.dataset.mode; else root.dataset.mode = current.mode;
@@ -126,15 +137,16 @@
ready: null,
// The installed, valid themes as the server listed them, or null until /api/themes has answered.
themes: () => themes && themes.map(t => ({ id: t.id, displayName: t.displayName, tokens: t.tokens })),
state: () => ({ theme: current.theme, mode: current.mode, requested: current.requested, themeSource: current.themeSource, modeSource: current.modeSource, warning: current.warning, provisional: current.provisional, organization: org && { id: org.id, label: org.label }, saved: org?.saved ?? null, override: override && { ...override } }),
state: () => { const o = shown(), v = system ? systemOverride : override; return { theme: current.theme, mode: current.mode, requested: current.requested, themeSource: current.themeSource, modeSource: current.modeSource, warning: current.warning, provisional: current.provisional, organization: o && { id: o.id, label: o.label }, saved: o?.saved ?? null, override: v && { ...v } }; },
// Writes this browser's override for the organization (a theme, a mode, or both). false when storage refused it; the page still shows it until reload.
set(patch) {
if (onSystem()) { const next = Brand.appearanceOf({ ...(systemOverride || {}), ...patch }), ok = next ? store.write(SYSTEM_KEY, next) : true; systemOverride = next; showAppearance(ok); return ok; }
const next = Brand.appearanceOf({ ...(override || {}), ...patch });
const ok = next ? (org ? store.write(orgKey(org.id), next) : store.write(APPEARANCE_KEY, next)) : true;
override = next; showAppearance(ok); return ok;
},
// Removes the override: the organization's saved value, or else the default, shows again.
clear() { const ok = org ? store.remove(orgKey(org.id)) : store.remove(APPEARANCE_KEY); override = null; showAppearance(ok); return ok; },
clear() { if (onSystem()) { const ok = store.remove(SYSTEM_KEY); systemOverride = null; showAppearance(ok); return ok; } const ok = org ? store.remove(orgKey(org.id)) : store.remove(APPEARANCE_KEY); override = null; showAppearance(ok); return ok; },
// The seam for the organization switcher (stream S5): call it with the organization now shown and its saved appearance.
organization(id, saved, label) {
if (!orgId(id)) return;
@@ -151,6 +163,20 @@
override = readOverride();
paint();
document.dispatchEvent(new CustomEvent('mosaic-theme-change', {detail: {palette: current.theme, mode: current.mode, stored: true, warning: null, picked: current.theme}}));
// The open organization's saved appearance, read again when another organization opens (#1873 SP1).
const readBusiness = async () => {
try {
const { ok, body } = await getJSON('/api/business');
if (ok && orgId(body?.business?.id)) return window.MosaicAppearance.organization(body.business.id, body.business.appearance, body.business.id);
} catch (err) { if (err?.signedOut) return; }
// No fresh answer: keep the organization this browser last showed for its own override, but not its stale saved value.
if (org && !org.confirmed) { org.saved = null; showAppearance(); }
};
document.addEventListener('mosaic-org-switch', () => { readBusiness(); });
// The dashboard and an organization page share the shell: moving between them repaints the theme.
const repaintScope = () => { if (onSystem() !== system) showAppearance(); };
window.addEventListener('hashchange', repaintScope);
window.MosaicOrg?.ready?.then(repaintScope);
window.MosaicAppearance.ready = (async () => {
await Promise.allSettled([
(async () => {
@@ -161,14 +187,7 @@
} catch (err) { if (err?.signedOut) return; themes = []; themesUnavailable = true; }
showAppearance();
})(),
(async () => {
try {
const { ok, body } = await getJSON('/api/business');
if (ok && orgId(body?.business?.id)) return window.MosaicAppearance.organization(body.business.id, body.business.appearance, body.business.id);
} catch (err) { if (err?.signedOut) return; }
// No fresh answer: keep the organization this browser last showed for its own override, but not its stale saved value.
if (org && !org.confirmed) { org.saved = null; showAppearance(); }
})(),
readBusiness(),
]);
})();
$('palette').onchange = e => window.MosaicAppearance.set({ theme: e.target.value });
@@ -488,12 +507,22 @@
const box = $('bus-down');
// E2E5 review P2: the organization list is read first and on its own, so a failed bus-status read
// (likely when the bus is down) still refreshes the list, its banner and the Settings Start control.
// #1873 SP1: the dashboard lists every organization's bus on its own rows; this banner is an organization page's.
if (window.MosaicOrg && window.MosaicOrg.route().split('?')[0] === '/dashboard') { box.hidden = true; return; }
// An answer about an organization that is no longer open is dropped: the new one's read draws the banner.
// So is one drawn for a page left while it was read (#1873 SP2: the organization page draws none).
const where = () => window.MosaicOrg?.route().split('?')[0] === '/organization';
const asked = window.MosaicOrg?.id ?? null, onPage = where(), stale = () => (window.MosaicOrg?.id ?? null) !== asked || where() !== onPage;
if (window.MosaicOrg) {
const org = (await window.MosaicOrg.readList()).find(row => row.id === window.MosaicOrg.id);
const org = (await window.MosaicOrg.readList()).find(row => row.id === asked);
if (stale()) return;
// #1873 SP2: the organization's own page says it in its down banner, with the restart action: one banner, not two.
if (org?.busHealthy === false && onPage) { box.hidden = true; return; }
if (org?.busHealthy === false) { box.textContent = 'Bus unavailable'; box.hidden = false; window.MosaicConsole?.attachBus(box, 'Restart the bus'); return; }
}
try {
const s = await api('/api/bus-status');
if (stale()) return;
if (!s.down) { box.hidden = true; return; }
const b = s.boot;
box.replaceChildren(node('b', '', 'Bus down: organization file invalid. '), node('span', '', `${b.reason} `), node('span', 'small muted', `File ${b.file}. Refused at ${b.at}. Last good load: ${b.lastGood ?? 'none'}. Fix the file, then restart the bus.`));
@@ -528,11 +557,28 @@
function showMachine() { $('show-machine').checked = machine; document.body.classList.toggle('machine-off', !machine); }
$('show-machine').onchange = e => {
machine = e.target.checked; showMachine();
try { localStorage.setItem(boardKey, JSON.stringify({ machine })); } catch {}
try { localStorage.setItem(boardKey(), JSON.stringify({ machine })); } catch {}
if (machine) { $('status').textContent = 'Loading board…'; fresh(); refresh(); } else hideMachine();
};
showMachine();
if (!machine) hideMachine();
// #1873 SP1: another organization opened in place. Its board setting and bus state are its own.
const onOrgSwitch = () => {
machine = readMachine(); showMachine();
if (machine) { fresh(); refresh(); } else { hideMachine(); busDown(); }
};
document.addEventListener('mosaic-org-switch', onOrgSwitch);
// An address with no organization picks one after the first list read; its own setting applies then.
window.MosaicOrg?.ready?.then(() => { if (readMachine() !== machine) onOrgSwitch(); });
// The banner hides on the system dashboard, gives way to the organization page's own down banner,
// and shows on the organization's other pages, so a move across those lines redraws it. Other moves
// inside one organization read nothing (the switch path reads its own).
let busPlace = null;
window.addEventListener('hashchange', () => {
if (!window.MosaicOrg) return;
const path = window.MosaicOrg.route().split('?')[0], now = ['/dashboard', '/organization'].includes(path) ? path : 'page';
if (now !== busPlace) { busPlace = now; busDown(); }
});
$('refresh').onclick = refresh;
$('mobile-pause').onclick = () => $('pause').click();
$('pause').onclick = () => { paused = !paused; $('pause').querySelector('span').textContent = paused ? 'Resume' : 'Pause'; $('pause').setAttribute('aria-label', paused ? 'Resume' : 'Pause'); $('pause').title = paused ? 'Resume' : 'Pause'; $('mobile-pause').textContent = paused ? 'Resume' : 'Pause'; $('pause').setAttribute('aria-pressed', String(paused)); schedule(); if (data) render(); };
+88
View File
@@ -0,0 +1,88 @@
/* #1873 SP6: the Assistant page (r2-13). A bar with the page heading and "Open thread", then up to
three thread panes as cards side by side, each with its own header (title, organization and
project chips, close), its own scroll and its own composer. One pane and a tab strip on a phone.
Loaded after shell.css and chat.css; every rule is scoped to the Assistant page. */
html[data-organizations] .assist{display:flex;flex-direction:column;gap:10px;min-width:0}
html[data-organizations] .assist-bar{display:flex;align-items:flex-start;gap:12px;flex-wrap:wrap}
html[data-organizations] .assist-vh{flex:1 1 320px;min-width:0}
html[data-organizations] .assist-vh h1{margin:0}
html[data-organizations] .assist-vh h1:focus{outline:none}
html[data-organizations] .assist-vh .sub{margin:4px 0 0;color:var(--muted);font-size:14px}
html[data-organizations] .assist-tools{display:flex;align-items:center;gap:8px;flex-wrap:wrap}
html[data-organizations] .assist-open{min-width:220px;max-width:100%;font:500 14px/1.4 var(--font);color:var(--text);background:var(--surface);border:1px solid var(--line);border-radius:var(--r);padding:6px 8px}
html[data-organizations] .assist-open:disabled{color:var(--muted);cursor:not-allowed}
html[data-organizations] .assist [data-assist-unread]:empty,html[data-organizations] .assist [data-assist-note]:empty{display:none}
html[data-organizations] .assist [data-assist-unread] .note{margin:0}
html[data-organizations] .assist [data-assist-note]{margin:0;font-size:13px;color:var(--muted)}
html[data-organizations] .assist [data-assist-note][data-refused]{color:var(--warning);font-weight:600}
html[data-organizations] .assist-new{border:1px solid var(--line);border-radius:var(--r);background:var(--surface);padding:12px 14px;display:grid;gap:10px}
html[data-organizations] .assist-new[hidden]{display:none}
html[data-organizations] .assist-new h2{margin:0;font-size:16px}
html[data-organizations] .assist-new h2:focus{outline:none}
html[data-organizations] .assist-new-fields{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:10px}
html[data-organizations] .assist-new-fields label{display:grid;gap:4px;font-size:13px;color:var(--muted);min-width:0}
html[data-organizations] .assist-new-fields select,html[data-organizations] .assist-new-fields input{font:500 14px/1.4 var(--font);color:var(--text);background:var(--canvas);border:1px solid var(--line);border-radius:var(--r);padding:6px 8px;min-width:0}
html[data-organizations] .assist-new-actions{display:flex;gap:8px;flex-wrap:wrap}
html[data-organizations] .assist-new .ws-btn.primary{background:var(--action);color:var(--onAction);border-color:var(--action)}
html[data-organizations] .assist-new .ws-btn.primary:hover:not(:disabled){background:color-mix(in srgb,var(--action) 88%,var(--strong))}
html[data-organizations] .assist-new [data-assist-new-status]{margin:0;font-size:13px}
html[data-organizations] .assist-new [data-assist-new-status]:empty{display:none}
html[data-organizations] .assist-tabs{display:none;margin-left:0;max-width:100%;flex-wrap:wrap}
html[data-organizations] .assist-tabs>button{max-width:60vw;overflow:hidden;text-overflow:ellipsis;min-height:32px;padding:2px 10px}
html[data-organizations] .assist-panes{display:grid;grid-template-columns:repeat(var(--assist-n,1),minmax(0,1fr));gap:12px;min-height:0}
html[data-organizations] .assist-panes[hidden]{display:none}
html[data-organizations] .assist-pane{display:flex;flex-direction:column;min-width:0;min-height:0;border:1px solid var(--line);border-radius:var(--r);background:var(--surface);overflow:hidden}
html[data-organizations] .assist-pane-h{display:flex;align-items:center;gap:8px;padding:10px 12px;border-bottom:1px solid var(--line);box-shadow:inset 0 3px 0 var(--org,var(--line));min-width:0;flex-wrap:wrap}
html[data-organizations] .assist-pane-h h2{margin:0;font-size:15px;font-weight:700;color:var(--strong,var(--text));overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:5em;flex:1 1 0}
html[data-organizations] .assist-pane-h h2:focus{outline:none}
html[data-organizations] .assist-chips{display:inline-flex;gap:6px;flex-wrap:wrap;min-width:0;order:1;flex:1 0 100%}
html[data-organizations] .assist-chips:empty{display:none}
/* SP7: a pane's tools (Full view, Messages, close) stay together on the title's row; the chips take the row under it.
A pane too narrow for them wraps the tools, never pushes one past the pane's edge. */
html[data-organizations] .assist-pane-tools{display:inline-flex;align-items:center;justify-content:flex-end;gap:2px;flex:0 1 auto;flex-wrap:wrap;max-width:100%;margin-left:auto}
html[data-organizations] .assist-chips .ws-chip{max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
html[data-organizations] .assist .pane-tool{display:inline-grid;place-items:center;width:28px;height:28px;border-radius:var(--r);color:var(--muted);border:0;background:none;padding:0;min-height:0;cursor:pointer;flex:none}
html[data-organizations] .assist .pane-tool:hover{background:var(--raised);color:var(--text)}
/* SP7: each pane's own organization's Messages page, a text link among the pane's tools. */
html[data-organizations] .assist .pane-tool.assist-msgs{width:auto;padding:0 8px;font-size:12px;font-weight:600;text-decoration:none}
/* SP7: "Resume assistant" under a pane's composer is a small secondary control, not a second primary button. */
html[data-organizations] .assist-body .btn.pane-resume{align-self:flex-start;min-height:0;padding:2px 8px;margin-top:4px;font-size:12px;font-weight:500;background:none;border-color:transparent;color:var(--muted)}
html[data-organizations] .assist-body .btn.pane-resume:hover:not(:disabled){background:var(--raised);color:var(--text)}
html[data-organizations] .assist .pane-tool svg.i{width:15px;height:15px;fill:none;stroke:currentColor;stroke-width:1.8;stroke-linecap:round;stroke-linejoin:round}
html[data-organizations] .assist-line{margin:0;padding:6px 12px;border-bottom:1px solid var(--line);font-size:13px;color:var(--text);background:color-mix(in srgb,var(--warn,#b7791f) 12%,var(--surface))}
html[data-organizations] .assist-line[hidden]{display:none}
html[data-organizations] .assist-body{flex:1;min-height:0;overflow:auto;padding:12px;display:flex;flex-direction:column}
/* The chat thread view in a pane: the log scrolls, the composer stays at the foot of the card.
Messages read as the project conversation's bubbles (projects.css scopes those to .project-chat,
whose page-level layout a pane must not take), sized for a third of the screen. */
html[data-organizations] .assist-body .chat-log{flex:1 1 0;min-height:120px;max-height:none;overflow:auto;margin:8px 0 0;padding:0;border:0}
html[data-organizations] .assist-body .chat-log>li{border:0;display:flex;flex-direction:column;align-items:flex-start;gap:4px;padding-block:6px}
html[data-organizations] .assist-body .chat-log>li.chat-message-human{align-items:flex-end}
html[data-organizations] .assist-body .chat-log>li>.chat-body{background:var(--raised);border:1px solid var(--line);border-radius:12px;padding:8px 12px;max-width:100%;box-sizing:border-box;overflow-wrap:anywhere}
html[data-organizations] .assist-body .chat-log>li.chat-message-human>.chat-body{background:var(--accent-fill);color:var(--on-accent);border-color:transparent}
html[data-organizations] .assist-body .chat-message-meta{display:flex;align-items:center;gap:6px;opacity:1;font-size:12px;color:var(--muted)}
html[data-organizations] .assist-body .chat-message-meta strong{color:var(--text);font-weight:600}
html[data-organizations] .assist-body .chat-avatar{display:grid;place-items:center;flex:none;width:24px;height:24px;border-radius:50%;background:var(--raised);color:var(--action);font-weight:700;font-size:12px}
html[data-organizations] .assist-body .chat-message-human .chat-avatar{background:var(--accent-fill);color:var(--on-accent)}
html[data-organizations] .assist-body>.chat-area{max-width:none;margin:0;flex:1 1 auto;min-height:0;display:flex;flex-direction:column}
html[data-organizations] .assist-body .chat-conversation{flex:1 1 auto;min-height:0;display:flex;flex-direction:column}
html[data-organizations] .assist-body .chat-conversation>p.small{margin:0;font-size:12px}
html[data-organizations] .assist-body form{margin-top:auto;padding-top:10px}
html[data-organizations] .assist-body .chat-conversation>button,html[data-organizations] .assist-body form>button{align-self:flex-start;justify-self:start;width:auto}
html[data-organizations] .assist-body textarea{width:100%;box-sizing:border-box;min-height:56px;height:56px}
html[data-organizations] .assist-empty{margin:24px 0;color:var(--muted)}
html[data-organizations] .assist-empty[hidden]{display:none}
@media (max-width:760px){
html[data-organizations] .assist-tabs:not([hidden]){display:inline-flex}
html[data-organizations] .assist-panes{grid-template-columns:minmax(0,1fr);height:auto}
html[data-organizations] .assist-pane.alt{display:none}
html[data-organizations] .assist-body{overflow:visible}
html[data-organizations] .assist-body .chat-log{flex:none;min-height:0;overflow:visible}
html[data-organizations] .assist-open{flex:1 1 100%;min-width:0}
html[data-organizations] .assist-tools{flex:1 1 100%}
html[data-organizations] .assist-new-fields{grid-template-columns:minmax(0,1fr)}
}
+568
View File
@@ -0,0 +1,568 @@
// #1873 SP6: the Assistant page (#/assistant), one system page with no organization prefix. Up to
// three chat threads, from any organization on the list, open next to each other. Each pane is the
// chat thread view (chat.js) in its own instance pinned to the pane's organization, so its reads and
// its sends name that organization in the address whichever organization the page opened last.
// A phone shows one pane at a time with a tab strip.
//
// The open set, its order and the phone's shown pane live in the address
// (#/assistant?open=<org>:<thread>,…&show=<org>:<thread>), checked before use and rewritten with
// replaceState. A bare #/assistant opens the set this browser had last.
//
// SP7: a plain click on a thread link anywhere in the Console (a project's conversation rows, the
// sidebar's thread links) opens that thread as a pane here, added to the open set; #/assistant?add=<org>:<thread>
// carries it across the page change. A link marked data-full-view (a pane's Full view, a requirement's
// "Open conversation") and a per-organization chat address typed or pasted open that organization's own chat view.
(() => {
'use strict';
if (!document.documentElement.hasAttribute('data-organizations')) return;
const data = window.MosaicWorkspaceData, ws = () => window.MosaicWorkspace;
const esc = value => String(value ?? '').replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
const enc = encodeURIComponent;
const MAX = 3, POLL = 10000, LIST_TTL = 3000, INFO_TTL = 30000, STORE = 'mosaic-assistant-open-v1';
const ORG = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
const paused = () => document.getElementById('pause')?.getAttribute('aria-pressed') === 'true';
const load = () => { try { return localStorage.getItem(STORE); } catch { return null; } };
const save = value => { try { localStorage.setItem(STORE, value); } catch {} };
const svg = d => `<svg class="i sm" viewBox="0 0 24 24" aria-hidden="true" focusable="false">${d}</svg>`;
const CLOSE = svg('<path d="M6 6l12 12M18 6 6 18"/>');
const setHtml = (el, html) => { if (el && el.innerHTML !== html) el.innerHTML = html; };
const setText = (el, text) => { if (el && el.textContent !== text) el.textContent = text; };
const rowsOf = body => (Array.isArray(body?.rows) ? body.rows : null);
// "<org>:<thread>,…" from the address: valid selectors only, each once, at most three.
function parse(query) {
const q = new URLSearchParams(query || ''), keys = [];
for (const part of (q.get('open') || '').split(',')) {
const cut = part.indexOf(':');
if (cut < 1) continue;
const org = part.slice(0, cut), id = part.slice(cut + 1).toLowerCase();
if (!ORG.test(org) || !UUID.test(id)) continue;
const key = `${org}:${id}`;
if (!keys.includes(key) && keys.length < MAX) keys.push(key);
}
const want = q.get('show') || '', at = want.indexOf(':');
const show = at > 0 ? `${want.slice(0, at)}:${want.slice(at + 1).toLowerCase()}` : null;
return { keys, show: keys.includes(show) ? show : null, named: q.has('open') };
}
const split = key => { const cut = key.indexOf(':'); return { org: key.slice(0, cut), id: key.slice(cut + 1) }; };
// ---------- reads ----------
// The organization list, and per organization its threads, projects and whether this Console may
// send there (its config's chatSend). An organization whose bus is down is not read.
let listAt = 0, listPromise = null;
const infos = new Map();
function orgList(fresh = false) {
if (!listPromise || fresh || Date.now() - listAt > LIST_TTL) {
listAt = Date.now();
listPromise = Promise.all([data.organizations(), ws()?.themes?.()]).then(([rows]) => (Array.isArray(rows) ? rows : null)).catch(() => null);
}
return listPromise;
}
const readConfig = org => fetch(`/api/orgs/${enc(org)}/config`, { cache: 'no-store', redirect: 'manual' })
.then(r => (r.ok ? r.json() : null)).then(c => c?.chatSend === true).catch(() => false);
function info(org, fresh = false) {
if (!org || org.invalid || org.busHealthy === false) return Promise.resolve({ threads: null, projects: null, chatSend: false, read: false });
const hit = infos.get(org.id);
if (hit && !fresh && Date.now() - hit.at < INFO_TTL) return hit.promise;
const promise = Promise.all([
data.threads(org.id).then(rowsOf).catch(() => null),
data.projects(org.id).then(rowsOf).catch(() => null),
readConfig(org.id),
]).then(([threads, projects, chatSend]) => ({
threads: threads && threads.filter(t => t && !t.shared && typeof t.id === 'string' && UUID.test(t.id)),
projects: projects && projects.filter(p => p && typeof p.id === 'string'),
chatSend, read: true,
}));
infos.set(org.id, { at: Date.now(), promise });
return promise;
}
// The rows ws().orgsOf reads: an organization not ok is named at the top of the page.
function orgRows(list, got) {
return list.map(o => {
const why = o.invalid ? ['invalid', o.reason || ''] : o.busHealthy === false ? ['down', ws().state(o)[2]] : got.get(o.id)?.threads === null ? ['timeout', 'the thread list did not answer'] : ['ok', ''];
return { org: o.id, label: o.label, theme: o.theme, state: why[0], reason: why[1] };
});
}
// ---------- state ----------
let mounted = null; // { root, panes: [pane], show, turn, timer, list, got, o, form }
let mountGen = 0, paneSeq = 0;
function writeUrl() {
if (!mounted) return;
const keys = mounted.panes.map(p => p.key);
const qs = keys.length ? `open=${keys.join(',')}${mounted.show && mounted.show !== keys[0] ? `&show=${mounted.show}` : ''}` : '';
save(keys.join(','));
const next = qs ? `#/assistant?${qs}` : '#/assistant';
if (location.hash !== next) history.replaceState(null, '', next);
}
// ---------- markup ----------
function frame() {
return `<section class="assist" data-assistant aria-labelledby="assist-title">
<div class="assist-bar">
<div class="assist-vh"><h1 id="assist-title" tabindex="-1">Assistant</h1>
<p class="sub">Threads from any organization, side by side. Each pane reads and sends through its own organization.</p></div>
<div class="assist-tools">
<label class="ws-sr" for="assist-open">Open thread</label>
<select id="assist-open" class="assist-open" data-assist-open><option value="">Open thread…</option></select>
</div>
</div>
<div data-assist-unread></div>
<p class="note" data-assist-note role="status"></p>
<form class="assist-new" data-assist-new hidden aria-labelledby="assist-new-title">
<h2 id="assist-new-title" tabindex="-1">New thread in <span data-assist-new-org></span></h2>
<div class="assist-new-fields">
<label><span>Project</span><select name="project" required></select></label>
<label><span>Agent</span><select name="instance" required></select></label>
<label><span>Name</span><input name="name" required maxlength="200" autocomplete="off"></label>
</div>
<div class="assist-new-actions"><button class="ws-btn primary" type="submit">Start thread</button><button class="ws-btn" type="button" data-assist-new-cancel>Cancel</button></div>
<p class="note" data-assist-new-status role="status"></p>
</form>
<div class="ws-seg assist-tabs" role="group" aria-label="Shown thread" data-assist-tabs></div>
<div class="assist-panes" data-assist-panes></div>
<p class="assist-empty" data-assist-empty hidden>No thread is open. Choose one under Open thread.</p>
</section>`;
}
function paneShell(p) {
const n = p.n;
return `<section class="assist-pane ws-o" data-assist-pane="${esc(p.key)}" id="assist-p${n}" aria-labelledby="assist-p${n}-title">
<div class="assist-pane-h">
<h2 id="assist-p${n}-title" data-assist-title>Reading…</h2>
<span class="assist-chips" data-assist-chips></span>
<span class="assist-pane-tools">
<a class="pane-tool assist-msgs" data-assist-pane-full data-full-view href="#/orgs/${enc(p.org)}/projects/threads/${enc(p.id)}">Full view</a>
<a class="pane-tool assist-msgs" data-assist-pane-messages href="#/orgs/${enc(p.org)}/messages" aria-label="Messages in ${esc(p.org)}">Messages</a>
<button type="button" class="pane-tool" data-assist-close aria-label="Close thread">${CLOSE}</button>
</span>
</div>
<p class="assist-line" data-assist-line role="status" hidden></p>
<div class="assist-body" data-assist-body></div>
</section>`;
}
const els = p => ({
title: p.el.querySelector('[data-assist-title]'), chips: p.el.querySelector('[data-assist-chips]'),
close: p.el.querySelector('[data-assist-close]'), full: p.el.querySelector('[data-assist-pane-full]'), messages: p.el.querySelector('[data-assist-pane-messages]'), line: p.el.querySelector('[data-assist-line]'), body: p.el.querySelector('[data-assist-body]'),
});
// The picker: every organization on the list, its threads, and "New thread in …" where this
// Console may send. A stopped, invalid or silent organization is named and offers nothing.
function pickerHtml(list, got) {
const open = new Set(mounted.panes.map(p => p.key));
const groups = (list || []).filter(o => o && typeof o.id === 'string' && ORG.test(o.id)).map(o => {
const name = ws().label(o), i = got.get(o.id);
if (o.invalid) return `<optgroup label="${esc(name)} · invalid"><option disabled value="">Organization invalid</option></optgroup>`;
if (o.busHealthy === false) return `<optgroup label="${esc(name)} · ${esc(ws().state(o)[2])}"><option disabled value="">No threads while its bus is down</option></optgroup>`;
if (!i?.threads) return `<optgroup label="${esc(name)} · not answering"><option disabled value="">Threads unavailable</option></optgroup>`;
const project = id => i.projects?.find(p => p.id === id)?.name;
const rows = i.threads.map(t => {
const key = `${o.id}:${t.id.toLowerCase()}`, where = project(t.project);
return `<option value="${esc(key)}"${open.has(key) ? ' disabled' : ''}>${esc(t.name || t.id)}${where ? ` · ${esc(where)}` : ''}${open.has(key) ? ' (open)' : ''}</option>`;
}).join('');
const fresh = i.chatSend ? `<option value="new:${esc(o.id)}">New thread in ${esc(name)}…</option>` : '';
return `<optgroup label="${esc(name)}">${rows || (fresh ? '' : '<option disabled value="">No threads</option>')}${fresh}</optgroup>`;
});
return `<option value="">Open thread…</option>${groups.join('')}`;
}
// ---------- drawing ----------
async function draw({ fresh = false, navigated = false } = {}) {
if (!mounted) return;
const gen = mountGen, turn = ++mounted.turn;
const live = () => mounted && gen === mountGen && turn === mounted.turn;
clearTimeout(mounted.timer);
const list = await orgList(fresh);
if (!live()) return;
const openOrgs = new Set(mounted.panes.map(p => p.org));
const valid = (list || []).filter(o => o && typeof o.id === 'string' && ORG.test(o.id));
const got = new Map(await Promise.all(valid.map(async o => [o.id, await info(o, fresh || (!navigated && openOrgs.has(o.id)))])));
if (!live()) return;
mounted.list = list; mounted.got = got;
mounted.o = ws().orgsOf({ orgs: orgRows(valid, got) });
paintTop();
for (const p of mounted.panes) drawPane(p);
paintTabs(); layout();
mounted.timer = setTimeout(tick, POLL);
}
function tick() {
if (!mounted) return;
if (paused()) { mounted.timer = setTimeout(tick, POLL); return; }
void draw();
}
// The line under the lead: how many panes are open, or why a thread was not opened (drawn as a warning).
function paintNote() {
const el = mounted.root.querySelector('[data-assist-note]');
setText(el, mounted.notice || (mounted.panes.length ? `${mounted.panes.length} open, up to ${MAX}` : ''));
el?.toggleAttribute('data-refused', !!mounted.notice);
}
function paintTop() {
const { root, list, o, panes } = mounted;
setHtml(root.querySelector('[data-assist-unread]'), list ? ws().unreadNote(o, [], 'assistant') : '<p class="note ws-unread-note">The organization list could not be read. Open panes only read.</p>');
paintNote();
const pick = root.querySelector('[data-assist-open]');
if (document.activeElement !== pick) { setHtml(pick, pickerHtml(list, mounted.got)); pick.value = ''; }
const full = panes.length >= MAX;
pick.disabled = full;
pick.title = full ? `${MAX} threads are open. Close one to open another.` : '';
root.querySelector('[data-assist-empty]').hidden = panes.length > 0;
}
function drawPane(p) {
if (!mounted || !p.el.isConnected) return;
const { list, got, o } = mounted, e = els(p);
const org = list?.find(x => x?.id === p.org) || null, i = got.get(p.org);
const name = org ? ws().label(org) : p.org;
const thread = i?.threads?.find(t => t.id.toLowerCase() === p.id) || null;
const title = thread?.name || `Thread ${p.id.slice(0, 8)}`;
p.title = title;
setText(e.title, title);
e.close.setAttribute('aria-label', `Close ${title}, ${name}`);
e.full.setAttribute('aria-label', `Full view of ${title}, ${name}`);
e.messages.setAttribute('aria-label', `Messages in ${name}`);
if (org) p.el.setAttribute('style', ws().colours(org)); else p.el.removeAttribute('style');
const project = thread && i.projects?.find(x => x.id === thread.project)?.name;
setHtml(e.chips, `${ws().orgChip(o, p.org)}${ws().projChip(project || '')}`);
let line = '', readable = true, why = 'Nothing is read for this thread.', back = false;
if (!list) line = 'The organization list could not be read, so sending is off here until it reads again.';
else if (!org) { line = `${p.org} is not on your organization list.`; readable = false; }
else if (org.invalid) { line = `${name}: organization invalid. Fix its file under Settings, Organizations.`; readable = false; }
else if (org.busHealthy === false) {
const how = org.busStopped ? 'stopped' : 'unavailable';
line = `${name}: bus is ${how}. This pane cannot read or send until it starts again; the other panes are not affected.`;
why = `Nothing is read for this thread while ${name}'s bus is ${how}.`; readable = false; back = true;
}
else if (i?.threads && !thread) line = `This thread is not in ${name}'s thread list.`;
// A held message the last render had no composer for stays in the line between polls, so the
// status line neither flickers nor is announced again on every read.
const withHeld = () => {
const cps = [...p.draft.replace(/\s+/g, ' ').trim()];
return `${line ? `${line} ` : ''}Your unsent message is kept until this thread can send: “${cps.length > 200 ? `${cps.slice(0, 200).join('')}…` : cps.join('')}”`;
};
const shown = readable && p.held && p.draft ? withHeld() : line;
setText(e.line, shown); e.line.hidden = !shown;
if (!readable) {
p.held = false;
// An unsent message outlives the chat view: it is held on the pane and put back when the
// thread reads again.
const typed = p.chat && e.body.querySelector('form textarea')?.value;
if (typed?.trim()) p.draft = typed;
p.chat?.dispose(); p.chat = null;
const kept = !p.draft ? '' : back ? ' Your unsent message is kept and comes back here when it reads again.' : ' Your unsent message is kept while this pane stays open.';
setHtml(e.body, `<p class="ws-line">${esc(why)}${kept}</p>`);
return;
}
if (!p.chat) { p.chat = window.MosaicChat.pane(p.org); p.first = true; }
const first = p.first, chat = p.chat, seq = ++p.seq; p.first = false;
void chat.render({ path: `/chat/threads/${p.id}`, container: e.body, canSend: !!list && i?.chatSend === true, navigated: first }).then(() => {
// Only the latest render of this pane decides: an earlier one that a newer render cut short
// has no composer yet and must not claim the thread cannot send.
if (seq !== p.seq || p.chat !== chat || !p.el.isConnected) return;
const field = p.draft ? e.body.querySelector('form textarea') : null;
if (p.draft && !field) {
// The thread reads but this render drew no composer (it cannot send now): the held message is
// quoted in the pane's status line until a composer is back to take it.
p.held = true; const text = withHeld(); setText(e.line, text); e.line.hidden = false;
return;
}
// Put the held message back only into an empty composer; text typed meanwhile is never overwritten.
if (field && !field.value) { field.value = p.draft; field.dispatchEvent(new Event('input', { bubbles: true })); }
if (field && field.value === p.draft) p.draft = '';
if (p.held && (field || !p.draft)) { p.held = false; setText(e.line, line); e.line.hidden = !line; }
}, () => {});
}
function paintTabs() {
const { root, panes, show } = mounted;
const tabs = root.querySelector('[data-assist-tabs]');
const focused = tabs.contains(document.activeElement) ? document.activeElement.dataset.assistShow : null;
const html = panes.map(p => `<button type="button" data-assist-show="${esc(p.key)}" aria-pressed="${show === p.key}" aria-controls="assist-p${p.n}">${esc(p.title || 'Reading…')}</button>`).join('');
if (tabs.innerHTML !== html) { tabs.innerHTML = html; if (focused) tabs.querySelector(`[data-assist-show="${CSS.escape(focused)}"]`)?.focus({ preventScroll: true }); }
tabs.hidden = panes.length < 2;
}
function layout() {
const { root, panes, show } = mounted;
const box = root.querySelector('[data-assist-panes]');
box.style.setProperty('--assist-n', String(Math.max(1, panes.length)));
box.hidden = !panes.length;
for (const p of panes) p.el.classList.toggle('alt', show !== p.key);
fit();
}
// Wide screens: the panes fill the window below the bar and each scrolls on its own.
const wide = window.matchMedia('(min-width: 761px)');
function fit() {
if (!mounted) return;
const box = mounted.root.querySelector('[data-assist-panes]');
if (!wide.matches) { box.style.height = ''; return; }
const foot = document.querySelector('body > .foot, .foot')?.getBoundingClientRect().height || 0;
const top = box.getBoundingClientRect().top;
box.style.height = `${Math.max(360, Math.floor(window.innerHeight - Math.max(top, 0) - foot - 16))}px`;
}
// ---------- panes ----------
// SP11: a pane's unsent message is kept per thread for the life of the browser tab, so leaving the
// Assistant page (a Full view link included) and coming back puts it in the composer again.
// sessionStorage can be missing or refuse a write; the Map still keeps it while the page lives.
// SP14: the kept messages belong to the person who typed them. They are stored with the viewer the
// page's /api/config read names (bus.js, window.MosaicViewer), and read back only by a page that
// read the same viewer. An entry stored under another viewer, or under none (an older entry, a
// failed read), is removed unread, so a tab that never saw a sign-out (another tab signed out, the
// session expired) does not hand one person's text to the next. A Console with no sign-in has one
// fixed viewer. Until the viewer is read nothing is written; with none, messages live only in the page.
const DRAFTS = 'mosaic-assistant-drafts';
const kept = new Map();
let viewer = null, known = false, viewerRead = null;
const saveKept = () => {
if (!known) return;
try { if (kept.size && viewer) sessionStorage.setItem(DRAFTS, JSON.stringify({ viewer, drafts: Object.fromEntries(kept) })); else sessionStorage.removeItem(DRAFTS); } catch { /* the Map still holds it */ }
};
const ready = () => (viewerRead ??= (async () => {
let v = null, stored = null;
try { v = await window.MosaicViewer; } catch { /* no viewer */ }
try { stored = JSON.parse(sessionStorage.getItem(DRAFTS) || 'null'); } catch { /* none kept */ }
viewer = typeof v === 'string' && v ? v : null;
known = true;
const own = !draftsOff && viewer && stored && typeof stored === 'object' && stored.viewer === viewer && stored.drafts && typeof stored.drafts === 'object' && !Array.isArray(stored.drafts);
if (own) for (const [k, t] of Object.entries(stored.drafts)) if (!kept.has(k) && typeof t === 'string' && t.trim() && parse(`open=${k}`).keys[0] === k) kept.set(k, t);
saveKept();
})());
const typedIn = p => p.chat?.draft?.() || p.draft || p.el?.querySelector('form textarea')?.value || '';
// Signed out, by an expired session or by the Sign out form: the kept drafts go and nothing is kept
// again, not even by the pagehide the form's own submit causes, so the next person to sign in on
// this tab never sees text typed before.
let draftsOff = false;
function keep(p) { if (draftsOff) return; const text = typedIn(p); if (text.trim()) kept.set(p.key, text); else kept.delete(p.key); saveKept(); }
function drop(p) { if (kept.delete(p.key)) saveKept(); }
window.addEventListener('pagehide', () => { if (mounted) for (const p of mounted.panes) keep(p); });
function forgetDrafts() {
draftsOff = true; kept.clear(); saveKept();
try { sessionStorage.removeItem(DRAFTS); } catch { /* nothing to remove */ }
if (mounted) for (const p of mounted.panes) { p.draft = ''; const t = p.el?.querySelector('form textarea'); if (t) t.value = ''; }
}
document.addEventListener('mosaic-signed-out', forgetDrafts);
document.addEventListener('submit', e => { if (e.target?.id === 'sign-out') forgetDrafts(); }, true);
function makePane(key) {
const { org, id } = split(key);
const p = { key, org, id, n: ++paneSeq, el: null, chat: null, first: true, title: null, draft: kept.get(key) || '', held: false, seq: 0 };
const box = mounted.root.querySelector('[data-assist-panes]');
box.insertAdjacentHTML('beforeend', paneShell(p));
p.el = box.lastElementChild;
return p;
}
function addPane(key, { focus = false } = {}) {
if (!mounted) return;
const had = mounted.panes.find(p => p.key === key);
if (had) { mounted.show = key; paintTabs(); layout(); writeUrl(); return; }
if (mounted.panes.length >= MAX) return;
const p = makePane(key);
mounted.panes.push(p); mounted.show = key;
writeUrl();
if (mounted.got) { paintTop(); drawPane(p); paintTabs(); layout(); }
if (focus) els(p).title.setAttribute('tabindex', '-1'), els(p).title.focus({ preventScroll: true });
}
// SP7: a thread opened from a link takes a free slot or, with all three taken, the place of the
// first pane that holds no unsent message. When every pane holds one, nothing is replaced.
// SP11: a pane whose send is in flight, or whose sent message the conversation does not show yet,
// is held too, until its receipt is in.
const holds = p => !!p.draft.trim() || !!p.chat?.hasDraft() || !!p.chat?.busy?.();
function place(key) {
const had = mounted.panes.find(p => p.key === key);
if (had) return had;
if (mounted.panes.length < MAX) { const p = makePane(key); mounted.panes.push(p); return p; }
const old = mounted.panes.find(p => !holds(p));
if (!old) return null;
const p = makePane(key);
drop(old); old.chat?.dispose(); old.chat = null; old.el.replaceWith(p.el);
mounted.panes[mounted.panes.indexOf(old)] = p;
return p;
}
const REFUSED = `That thread was not opened: all ${MAX} panes hold an unsent message or a message waiting to show. Send or clear one, wait for a sent message to show, or close a pane, then open the thread again.`;
function add(key) {
if (!mounted) return false;
const p = place(key);
if (!p) { mounted.notice = REFUSED; paintNote(); return false; }
mounted.notice = ''; mounted.show = key;
writeUrl();
if (mounted.got) { paintTop(); drawPane(p); paintTabs(); layout(); }
els(p).title.setAttribute('tabindex', '-1'); els(p).title.focus({ preventScroll: true });
return true;
}
const addOf = query => { const v = new URLSearchParams(query || '').get('add'); return v ? parse(new URLSearchParams({ open: v }).toString()).keys[0] || null : null; };
const THREAD_LINK = /^#\/(?:orgs\/([^/?#]+)\/)?(?:projects|chat)\/threads\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
document.addEventListener('click', e => {
if (e.defaultPrevented || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
const a = e.target.closest?.('a[href]');
// A link marked data-full-view (a pane's Full view, a requirement's "Open conversation") goes to the
// organization's own thread view, which has Request details, sessions and sharing.
if (!a || a.hasAttribute('download') || a.hasAttribute('data-full-view') || (a.target && a.target !== '_self')) return;
const m = THREAD_LINK.exec(a.getAttribute('href') || '');
const org = m && (m[1] || window.MosaicOrg?.id);
if (!m || !org || !ORG.test(org)) return;
e.preventDefault();
const key = `${org}:${m[2].toLowerCase()}`;
if (mounted && /^#\/assistant(?:\?|$)/.test(location.hash)) add(key);
else location.hash = `#/assistant?add=${key}`;
});
// SP11: closing a pane that holds unsent text asks first; a close drops the kept text.
function closePane(p) {
if (!mounted || !p) return;
const at = mounted.panes.indexOf(p);
if (at < 0) return;
if (typedIn(p).trim() && !window.confirm(`Close ${p.title || 'this thread'}? Its unsent message is lost.`)) return;
drop(p);
mounted.notice = '';
p.chat?.dispose(); p.chat = null; p.el.remove();
mounted.panes.splice(at, 1);
const next = mounted.panes[Math.min(at, mounted.panes.length - 1)];
if (mounted.show === p.key) mounted.show = next?.key ?? null;
writeUrl(); paintTop(); paintTabs(); layout();
// The close button just left the page: focus the next pane's close control, or the picker.
(next ? els(next).close : mounted.root.querySelector('[data-assist-open]')).focus({ preventScroll: true });
}
// ---------- a new thread ----------
async function openForm(orgId) {
if (!mounted) return;
const org = mounted.list?.find(o => o?.id === orgId);
if (!org || org.busHealthy === false || mounted.got.get(orgId)?.chatSend !== true) return;
const f = mounted.root.querySelector('[data-assist-new]'), formTurn = ++mounted.formTurn;
mounted.form = { org: orgId, busy: false };
f.hidden = false; f.reset();
setText(f.querySelector('[data-assist-new-org]'), ws().label(org));
setText(f.querySelector('[data-assist-new-status]'), 'Reading projects and agents…');
const project = f.elements.project, instance = f.elements.instance;
project.innerHTML = ''; instance.innerHTML = ''; project.disabled = true; instance.disabled = true;
f.querySelector('h2').focus({ preventScroll: true });
const [i, agents] = await Promise.all([
info(org, true),
fetch(`/api/orgs/${enc(orgId)}/chat/instances`, { cache: 'no-store', redirect: 'manual' }).then(r => (r.ok ? r.json() : null)).then(rowsOf).catch(() => null),
]);
if (!mounted || mounted.formTurn !== formTurn || f.hidden) return;
const projects = (i.projects || []).filter(p => !p.archived);
project.innerHTML = projects.map(p => `<option value="${esc(p.id)}">${esc(p.name || p.id)}</option>`).join('');
instance.innerHTML = (agents || []).filter(a => a && typeof a.instance === 'string').map(a => `<option value="${esc(a.instance)}">${esc(a.name || a.instance)}</option>`).join('');
project.disabled = !projects.length; instance.disabled = !agents?.length;
const missing = [i.projects === null ? 'Projects could not be read.' : !projects.length ? 'This organization has no open project.' : '', agents === null ? 'Agents could not be read.' : !agents.length ? 'No agent takes threads here.' : ''].filter(Boolean).join(' ');
setText(f.querySelector('[data-assist-new-status]'), missing);
}
function closeForm() {
if (!mounted) return;
mounted.form = null; mounted.formTurn++;
mounted.root.querySelector('[data-assist-new]').hidden = true;
}
async function submitForm(f) {
const form = mounted?.form;
if (!form || form.busy) return;
const status = f.querySelector('[data-assist-new-status]');
const body = { project: f.elements.project.value, name: f.elements.name.value.trim(), instance: f.elements.instance.value };
if (!body.project || !body.instance || !body.name) { setText(status, 'Choose a project and an agent, and name the thread.'); return; }
form.busy = true;
const submit = f.querySelector('[type=submit]'); submit.disabled = true;
setText(status, 'Starting the thread…');
let result = null, why = '';
try {
const r = await fetch(`/api/orgs/${enc(form.org)}/chat/threads`, { method: 'POST', cache: 'no-store', redirect: 'manual', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) });
const v = await r.json().catch(() => null);
if (r.ok && typeof v?.id === 'string' && UUID.test(v.id)) result = v.id.toLowerCase();
else why = r.type === 'opaqueredirect' || r.status === 401 ? 'You are signed out. Reload the page to sign in again.' : `The thread was not started${typeof v?.error === 'string' ? ` (${v.error})` : ''}.`;
} catch { why = 'Outcome unknown. Look under Open thread before trying again.'; }
if (mounted?.form !== form) return;
form.busy = false; submit.disabled = false;
if (!result) { setText(status, why); return; }
infos.delete(form.org);
const key = `${form.org}:${result}`;
if (mounted.panes.length >= MAX && !mounted.panes.some(p => p.key === key)) { setText(status, `Started. ${MAX} threads are open; close one to open it.`); return; }
closeForm();
addPane(key, { focus: true });
void draw({ fresh: false });
}
// ---------- events (bound once to the mount root) ----------
function bind(root) {
root.addEventListener('change', e => {
const pick = e.target.closest?.('[data-assist-open]');
if (!pick || !mounted) return;
const value = pick.value;
pick.value = '';
if (value.startsWith('new:')) { void openForm(value.slice(4)); return; }
const want = parse(`open=${value}`).keys[0];
if (want) { mounted.notice = ''; addPane(want); }
});
root.addEventListener('click', e => {
if (!mounted) return;
const show = e.target.closest?.('[data-assist-show]');
if (show) { const p = mounted.panes.find(x => x.key === show.dataset.assistShow); if (p) { mounted.show = p.key; paintTabs(); layout(); writeUrl(); } return; }
const close = e.target.closest?.('[data-assist-close]');
if (close) { closePane(mounted.panes.find(x => x.el.contains(close))); return; }
if (e.target.closest?.('[data-assist-new-cancel]')) { closeForm(); root.querySelector('[data-assist-open]').focus({ preventScroll: true }); }
});
root.addEventListener('submit', e => {
const f = e.target.closest?.('[data-assist-new]');
if (!f) return;
e.preventDefault();
void submitForm(f);
});
}
// ---------- public ----------
async function mount(container, query, { navigated = false } = {}) {
unmount();
const gen = ++mountGen;
// SP14: the kept messages are known only once the viewer is; a page left meanwhile mounts nothing.
await ready();
if (gen !== mountGen) return;
container.innerHTML = frame();
const root = container.querySelector('[data-assistant]');
mounted = { root, panes: [], show: null, turn: 0, timer: null, list: null, got: null, o: null, form: null, formTurn: 0, notice: '' };
bind(root);
window.addEventListener('resize', fit);
document.title = 'Assistant · Mosaic Console';
let want = parse(query);
if (!want.named) want = parse(`open=${load() || ''}`);
for (const key of want.keys) mounted.panes.push(makePane(key));
mounted.show = want.show || want.keys[0] || null;
// A thread link followed from another page: a fresh set holds no unsent message, so it always lands.
const extra = addOf(query), added = extra && place(extra);
if (added) mounted.show = extra;
if (added) { els(added).title.setAttribute('tabindex', '-1'); els(added).title.focus({ preventScroll: true }); }
else if (navigated) root.querySelector('h1').focus({ preventScroll: true });
writeUrl(); paintTabs(); layout();
root.querySelector('[data-assist-empty]').hidden = mounted.panes.length > 0;
// SP14: a full set offers no fourth from the start, not only once the organization reads answer.
root.querySelector('[data-assist-open]').disabled = mounted.panes.length >= MAX;
await draw({ navigated: true });
}
function unmount() {
if (!mounted) { mountGen++; return; }
clearTimeout(mounted.timer);
for (const p of mounted.panes) { keep(p); p.chat?.dispose(); }
window.removeEventListener('resize', fit);
mounted = null; mountGen++;
}
// The Console's Refresh, and a redraw of the same page: every pane reads again now. A query that
// names a different open set (an address edited in place) opens that set.
function refresh(query) {
if (!mounted) return;
if (typeof query === 'string') {
const want = parse(query);
if (want.named && want.keys.join(',') !== mounted.panes.map(p => p.key).join(',')) {
for (const p of [...mounted.panes]) if (!want.keys.includes(p.key)) { keep(p); p.chat?.dispose(); p.el.remove(); }
const kept = new Map(mounted.panes.map(p => [p.key, p]));
mounted.panes = want.keys.map(k => kept.get(k) || makePane(k));
const box = mounted.root.querySelector('[data-assist-panes]');
for (const p of mounted.panes) box.append(p.el);
mounted.show = want.show || want.keys[0] || null;
writeUrl();
}
const extra = addOf(query);
if (extra) add(extra);
}
infos.clear();
void draw({ fresh: true });
}
const hasDraft = () => !!mounted && mounted.panes.some(p => !!p.draft.trim() || !!p.chat?.hasDraft());
// A write that changed an organization reads it again.
document.addEventListener('mosaic-org-changed', e => { if (mounted && mounted.panes.some(p => p.org === e.detail?.org)) { infos.delete(e.detail.org); void draw(); } });
window.MosaicAssistant = Object.freeze({ mount, unmount, refresh, hasDraft, add });
})();
+19 -3
View File
@@ -181,11 +181,27 @@
menu.addEventListener('click', e => { if (e.target.closest('a')) close(); });
document.addEventListener('click', e => { if (!e.target.closest('.avatar-wrap')) close(); });
function breadcrumbs() {
const path = location.hash.slice(2).split('?')[0], parts = path.split('/').filter(Boolean), box = $('breadcrumbs');
draw();
// SP1: every page inside an organization says which one, after the dashboard: Dashboard / Acme / ...
const box = $('breadcrumbs'), org = /^#\/orgs\/[^/?]+/.test(location.hash) ? window.MosaicOrg : null;
if (box && org?.id && !box.querySelector('[data-crumb-org]') && !/^#\/orgs\/[^/?]+\/organization(?:[/?]|$)/.test(location.hash)) box.insertAdjacentHTML('afterbegin', `<a href="#/dashboard">Dashboard</a><span aria-hidden="true">/</span><a href="#/orgs/${encodeURIComponent(org.id)}/organization" data-crumb-org>${escape(org.label)}</a><span aria-hidden="true">/</span>`);
// SP7: a trail with nothing above the page only repeats the page's heading, so the heading names it once.
if (!box) return;
const heading = [...$('main').querySelectorAll('h1')].find(h => h.getClientRects().length)?.textContent.trim();
const echo = !box.querySelector('a') && !!heading && box.textContent.trim() === heading;
if (box.hidden !== echo) box.hidden = echo;
}
window.MosaicBreadcrumbs = breadcrumbs;
function draw() {
// SP1: an organization's pages are routes under #/orgs/<id>; the crumb reads the route inside it.
const path = location.hash.replace(/^#\/orgs\/[^/?]+/, '#').slice(2).split('?')[0], parts = path.split('/').filter(Boolean), box = $('breadcrumbs');
if (!box || !$('bus-view')) return;
if (window.MosaicProjects?.breadcrumb?.(box, $('bus-view'))) return;
if (!parts.length || parts[0] === 'board') { box.innerHTML = '<span aria-current="page">Dashboard</span>'; return; }
const names = {projects:'Projects',chat:'Projects',inbox:'Inbox',messages:'Messages',tasks:'Tasks',agents:'Agents',queue:'Queue',business:'Business',docs:'Docs',settings:'Settings'};
// Inside an organization the board is its control board; the system dashboard is the crumb before it.
if (parts[0] === 'board' && /^#\/orgs\//.test(location.hash)) { box.innerHTML = '<span aria-current="page">Control board</span>'; return; }
if (!parts.length || parts[0] === 'board' || parts[0] === 'dashboard') { box.innerHTML = '<span aria-current="page">Dashboard</span>'; return; }
if (parts[0] === 'organization') { const h = $('bus-view').querySelector('[data-org-dashboard] h1')?.textContent?.trim(); box.innerHTML = `<a href="#/dashboard">Dashboard</a>${h ? `<span aria-hidden="true">/</span><span aria-current="page">${escape(h)}</span>` : ''}`; return; }
const names = {projects:'Projects',chat:'Projects',inbox:'Inbox',messages:'Messages',assistant:'Assistant',tasks:'Tasks',agents:'Agents',workflows:'Workflows',queue:'Queue',business:'Business',docs:'Docs',settings:'Settings'};
if (parts[0] === 'settings' && parts[1] === 'business' && $('bus-view').querySelector('#settings-page-title')?.textContent.trim() === 'Business') { box.innerHTML = '<a href="#/settings">Settings</a><span aria-hidden="true">/</span><span aria-current="page">Business</span>'; return; }
const name = names[parts[0]] || 'Dashboard', heading = $('bus-view').querySelector('h1')?.textContent?.trim();
const project = $('bus-view').querySelector('.chat-conversation > p:first-child a, .chat-room > p:first-child a');
+308 -71
View File
@@ -75,13 +75,17 @@
window.MosaicIcons.succeeded();
return body;
}
// #1873 SP1: bumped by each in-place organization switch. A write, or a read that keeps its answer,
// captures it before its await and drops the answer when it changed, so nothing the old organization
// answered lands on the new page or in its kept answers.
let orgEpoch = 0;
// A reader for one render. `live` asks the server; otherwise only kept answers are used.
function reader(live) {
const used = [];
const get = async (verb, subject) => {
const k = subject === undefined ? verb : `${verb}:${subject}`;
let r;
if (live) { r = await fetchRead(verb, subject); last.set(k, r); }
if (live) { const epoch = orgEpoch; r = await fetchRead(verb, subject); if (epoch === orgEpoch) last.set(k, r); }
else if (!(r = last.get(k))) throw new ReadError('not-read', 'not read before');
used.push(r.at);
if (verb === 'messages') { messageCount = r.unread; return r; }
@@ -90,7 +94,7 @@
get.api = async path => {
const k = `api:${path}`;
let r;
if (live) { r = await fetchApi(path); last.set(k, r); }
if (live) { const epoch = orgEpoch; r = await fetchApi(path); if (epoch === orgEpoch) last.set(k, r); }
else if (!(r = last.get(k))) throw new ReadError('not-read', 'not read before');
used.push(r.at);
return r;
@@ -204,7 +208,7 @@
out.groupAs = m?.from_role === 'human' ? 'request' : m?.decision ? 'decision' : 'other';
} else if (r.table === 'decisions') {
out.kind = 'decision.raised'; out.decision = r.id; out.actor = { role: r.raised_by_role, run: r.raised_by_run };
out.text = `Raised a ${r.class} decision for ${r.route_to}: ${String(r.question).split('\n')[0]}`;
out.text = `Raised a ${String(classWord(r.class)).toLowerCase()} decision for ${r.route_to}: ${String(r.question).split('\n')[0]}`;
} else if (r.table === 'decision_events') {
// The human answers from the CLI (via cli) or, since row 252 (#1753), a grant request from the
// signed-in Console (via console); every other row is the broker's.
@@ -239,7 +243,9 @@
const badge = (text, kind = 'muted') => `<span class="badge badge-${kind}">${txt(text)}</span>`;
// Class chip: the decision class, the action in mono. BLOCKING is its own chip (CSS capitalises it; the text stays lowercase).
const CLASSES = ['routine', 'within-role', 'cross-role', 'gated'];
const chip = (cls, action) => `<span class="tag${CLASSES.includes(cls) ? ` tag-${cls}` : ''}">${txt(cls)} · <code>${txt(action)}</code></span>`;
// SP11: the class in the Inbox's words, from workspace.js's map.
const classWord = cls => window.MosaicWorkspace?.classWord?.(cls) ?? cls;
const chip = (cls, action) => `<span class="tag${CLASSES.includes(cls) ? ` tag-${cls}` : ''}">${txt(classWord(cls))} · <code>${txt(action)}</code></span>`;
const blockChip = text => `<span class="tag tag-block">${txt(text)}</span>`;
// An empty state says what would appear and where it comes from.
const empty = (what, from) => `<div class="empty"><b>${what}</b>${from ? `<p>${from}</p>` : ''}</div>`;
@@ -264,8 +270,8 @@
// ---------------------------------------------------------------- views
let inboxCount = null, messageCount = null;
// Organization mode (sample 01): Dashboard, Inbox, Tasks, Projects, Side by side, Agents and
// Assistant, with Settings pinned to the foot of the sidebar. Queue opens from the organization
// Organization mode (sample 01): Dashboard, Inbox, Tasks, Projects, Agents and Assistant (SP6:
// `#/assistant`, threads of any organization side by side), with Settings pinned to the foot of the sidebar. Queue opens from the organization
// dashboard and Docs from its Docs row, so neither is a sidebar item here.
function orgSections(route) {
const nav = $('console-nav');
@@ -275,9 +281,10 @@
const focused = $('sections').contains(active) || foot.contains(active) ? active.getAttribute('href') : null;
const icon = id => window.MosaicWorkspace?.icon?.(id) ?? `<svg class="i" aria-hidden="true"><use href="/icons.svg#i-${id}"/></svg>`;
const n = (count, what) => count > 0 ? `<span class="ws-n hot" aria-label="${count} ${what}">${count}</span>` : '';
const items = [['/', 'Dashboard', '', 'board'], ['/inbox', 'Inbox', n(inboxCount?.open, 'open for you'), 'inbox'], ['/tasks', 'Tasks', '', 'tasks'], ['/projects', 'Projects', '', 'folder'], ['/side-by-side', 'Side by side', '', 'columns'], ['/agents', 'Agents', '', 'agents'], ['/messages', 'Assistant', n(messageCount, 'unread messages'), 'talk']];
const items = [['/dashboard', 'Dashboard', '', 'board'], ['/inbox', 'Inbox', n(inboxCount?.open, 'open for you'), 'inbox'], ['/tasks', 'Tasks', '', 'tasks'], ['/projects', 'Projects', '', 'folder'], ['/agents', 'Agents', '', 'agents'], ['/assistant', 'Assistant', '', 'talk']];
const link = ([h, l, extra, id]) => {
const cur = h === '/' ? (route === '/' || route === '/board') : route.startsWith(h) || (h === '/projects' && route.startsWith('/chat')) || (h === '/tasks' && route.startsWith('/trail/task')) || (h === '/inbox' && (route.startsWith('/trail/decision') || route.startsWith('/trail/message')));
// #1873 SP1: the Dashboard item is the system dashboard, `#/dashboard`, outside any organization.
const cur = h === '/dashboard' ? (route === '/dashboard' || route === '/' || route === '/board') : route.startsWith(h) || (h === '/projects' && route.startsWith('/chat')) || (h === '/tasks' && route.startsWith('/trail/task')) || (h === '/inbox' && (route.startsWith('/trail/decision') || route.startsWith('/trail/message')));
return `<a href="#${h}" class="s1-section ws-nav"${cur ? ' aria-current="page"' : ''}>${icon(id)}<span class="t">${l}</span>${extra}</a>`;
};
// No project tree under Projects here: the sidebar's Projects group lists every organization's
@@ -314,7 +321,7 @@
// render. That read marks nothing. Row 150 (#1644): since row 142, `mosaic talk` prints only the
// reply to its own message, so a reply to a Console send stays unread in `mosaic inbox` until
// the human marks it read with `mosaic inbox --read`.
let isTester = false, orgSetup = false;
let isTester = false, orgSetup = false, triageOwner = false;
// Both Docs and project direction use the same owner-only records setup action.
window.MosaicRecords = {
markup(project) {
@@ -342,12 +349,14 @@
});
let configRead = Promise.resolve();
// #1873 SP1: the config read an organization switch started, until the next render has waited for it.
let switchRead = null;
let canSend = false, canMessage = false, chatSend = false, sendRoles = null, sending = false, receipt = null, replies = [];
const REPLIES = 50; // the broker's cap
function repliesHtml() {
if (replies === null) return '<p class="small warn">The replies to it could not be read. Read again to retry; <code>mosaic inbox</code> in a terminal lists them.</p>';
if (!replies.length) return '<p class="small muted">No reply yet. One shows here when the role answers, as the page refreshes.</p>';
return `<h3 class="small">Replies <span class="count">${replies.length}</span></h3><ol class="s1-plain s1-replies">${replies.map(m => `<li><p class="small muted">${txt(m.from_role)} ${when(m.at)} · ${txt(m.class)} · <a href="#/trail/message/${enc(m.id)}">trail</a></p><p class="s1-q">${txt(m.body)}</p></li>`).join('')}</ol>${replies.length >= REPLIES ? `<p class="small muted">The first ${REPLIES} replies show here.</p>` : ''}`;
return `<h3 class="small">Replies <span class="count">${replies.length}</span></h3><ol class="s1-plain s1-replies">${replies.map(m => `<li><p class="small muted">${txt(m.from_role)} ${when(m.at)} · ${txt(classWord(m.class))} · <a href="#/trail/message/${enc(m.id)}">trail</a></p><p class="s1-q">${txt(m.body)}</p></li>`).join('')}</ol>${replies.length >= REPLIES ? `<p class="small muted">The first ${REPLIES} replies show here.</p>` : ''}`;
}
const draft = { to: '', body: '' };
function composerHtml() {
@@ -462,14 +471,86 @@
if(!templatesOnly && d.op!=='fire' && !template){hireStatus='Read and choose a role template first.';hireCode='';paintHireStart();return;}
const thinking=d.thinking?.trim(),hire={op:d.op,level:d.level,name:d.name,reason:d.reason,...(d.level==='project'?{project:d.project}:{}),...(d.op==='fire'?{}:{role:{template:template?.name,sha256:template?.sha256},route:{harness:d.harness,model:d.model,...(thinking?{thinking}:{})}})};
hireBusy=true;hireStatus='';hireCode='';paintHireStart();
const epoch=orgEpoch;
const {res,json}=await decidePost(`/api/decisions/hire/${templatesOnly?'templates':'start'}`,{business:hireOrg() ?? d.business,...(templatesOnly?{}:{hire})});
if(epoch!==orgEpoch){if(res?.type==='opaqueredirect')signOut();return;}
hireBusy=false;
if(res?.type==='opaqueredirect'){signOut();return;}
if(res?.ok && templatesOnly && Array.isArray(json?.templates)){hireTemplates=json.templates;hireStatus=hireTemplates.length?'Templates read.':'No templates available.';}
else if(res?.ok && !templatesOnly && json?.op==='resolved'){hireStatus=`Recorded decision ${json.id}.`;}
else {const r=decideRefusal(res,json,templatesOnly?'confirmation-unavailable':'outcome-unknown');hireStatus=r.message;hireCode=r.code;}
paintHireStart();
// A hire, fire or change applied: the Agents page and any pane showing this organization draw it now.
if(res?.ok && !templatesOnly && json?.op==='resolved' && hireOrg())document.dispatchEvent(new CustomEvent('mosaic-org-changed',{detail:{org:hireOrg()}}));
}
// Fire from an agent card on the Agents page (ruling 2026-11-14, visibility): the same hire decision the
// form above raises with op fire, after an inline confirmation. On success the card goes at once, a
// receipt names the decision, and the page reads the organization again. The confirmation and the
// receipt live here so a redraw keeps them; workspace.js draws them from MosaicDecide.
const FIRE_REASON='Fired from the Agents page.';
let fireAsk=null,fireBusy=false,fireReceipt=null;
const fireKey=(org,name)=>`${org}\u0000${name}`;
// #1873 SP5: the system Agents page lists every organization's agents, so its controls carry their
// organization (data-agent-fire-org) and post to that organization's own bus, never to the one
// opened last. Its receipt box is `data-agents-receipt="*"` and shows a receipt from any of them.
// The agent cards keep the old shape: no attribute, the opened organization, canDecide.
function fireNote(scope=hireOrg()){const r=fireReceipt&&(scope==='*'?fireReceipt.system:fireReceipt.org===scope)?fireReceipt:null;
return r?`<p class="receipt${r.failed?' failed':''}" data-agents-receipt-text>${txt(r.text)}${r.code?` (<code>${txt(r.code)}</code>)`:''}</p>`:'';}
function paintFireNote(){for(const e of document.querySelectorAll('[data-agents-receipt]'))e.innerHTML=fireNote(e.dataset.agentsReceipt||hireOrg());}
const fireSel=(attr,name,org)=>`[${attr}="${CSS.escape(name)}"]${org?`[data-agent-fire-org="${CSS.escape(org)}"]`:':not([data-agent-fire-org])'}`;
async function fireAgent(name,named=null,orgName=named){
const org=named??hireOrg();
// A named organization was checked against its own config when the control was drawn (decidesIn).
if(fireBusy||!org||out()||(!named&&!canDecide)||isTester)return;
fireBusy=true;
for(const b of document.querySelectorAll('[data-agent-fire-yes],[data-agent-fire-no]'))b.disabled=true;
const epoch=orgEpoch;
const {res,json}=await decidePost(`${decideBase({ org: named })}/decisions/hire/start`,{business:org,hire:{op:'fire',level:'org',name,reason:FIRE_REASON}});
// SP5 review F7: a named organization's Fire went to that organization, so its outcome still
// stands after the opened organization changes.
// After a switch, busy and confirm state belong to whatever Fire started since; leave them alone.
const stale=epoch!==orgEpoch;
if(stale&&!named){if(res?.type==='opaqueredirect')signOut();return;}
if(!stale){fireBusy=false;fireAsk=null;}
if(res?.type==='opaqueredirect'){signOut();return;}
const where=named?` in ${orgName}`:'';
if(res?.ok && json?.op==='resolved'){
for(const c of document.querySelectorAll(`[data-org="${CSS.escape(org)}"] [data-agent-card="${CSS.escape(name)}"]`))c.remove();
for(const r of document.querySelectorAll(`[data-agents-org="${CSS.escape(org)}"] tr[data-agent="${CSS.escape(name)}"]`))r.remove();
for(const r of document.querySelectorAll(`[data-ws-agent="${CSS.escape(`${org}:${name}`)}"]`))r.remove();
fireReceipt={org,system:!!named,text:`Fired ${name}${where}. Recorded decision ${json.id}.`};
paintFireNote();announce(fireReceipt.text);
document.dispatchEvent(new CustomEvent('mosaic-org-changed',{detail:{org}}));
} else {
const r=decideRefusal(res,json,'outcome-unknown');
fireReceipt={org,system:!!named,failed:true,text:`${name}${where} was not fired: ${r.message}`,code:r.code};
paintFireNote();
for(const c of document.querySelectorAll(fireSel('data-agent-fire-confirm',name,named)))c.outerHTML=fireButton(name,named,orgName);
}
}
const fireOrgAttr=org=>org?` data-agent-fire-org="${esc(org)}"`:'';
const fireFocus=(kind,name,org)=>esc(org?`${kind}:${org}:${name}`:`${kind}:${name}`);
// SP5 review F5: the words name the organization by its label (`orgName`); its id addresses the control.
const fireNameAttr=(org,orgName)=>org&&orgName&&orgName!==org?` data-agent-fire-name="${esc(orgName)}"`:'';
const fireButton=(name,org=null,orgName=org)=>`<button type="button" class="btn small" data-agent-fire="${esc(name)}"${fireOrgAttr(org)}${fireNameAttr(org,orgName)} data-focus-key="${fireFocus('fire',name,org)}" aria-label="Fire ${esc(name)}${org?` in ${esc(orgName)}`:''}">Fire</button>`;
const fireConfirm=(name,org=null,orgName=org)=>`<span class="ws-fire-confirm" role="group" aria-label="Fire ${esc(name)}${org?` in ${esc(orgName)}`:''}?" data-agent-fire-confirm="${esc(name)}"${fireOrgAttr(org)}${fireNameAttr(org,orgName)}>Fire ${txt(name)}? <button type="button" class="btn small primary" data-agent-fire-yes="${esc(name)}"${fireOrgAttr(org)} data-focus-key="${fireFocus('fire-yes',name,org)}"${fireBusy?' disabled':''}>Confirm fire</button><button type="button" class="btn small" data-agent-fire-no="${esc(name)}"${fireOrgAttr(org)}${fireBusy?' disabled':''}>Cancel</button></span>`;
// What the agent card shows for one agent: nothing without the decide right or outside the page's own
// organization. SP5: `allowed` given means the caller read that organization's own config (decidesIn);
// the control is then drawn for that organization, whichever one was opened last.
function fireControl(org,name,allowed,orgName=org){
const named=typeof allowed==='boolean';
if(isTester||(named?!allowed:(!canDecide||org!==hireOrg())))return '';
return fireAsk===fireKey(org,name)?fireConfirm(name,named?org:null,named?orgName:null):fireButton(name,named?org:null,named?orgName:null);
}
document.addEventListener('click',e=>{
const t=e.target.closest?.('[data-agent-fire],[data-agent-fire-yes],[data-agent-fire-no]');
if(!t)return;
const named=t.dataset.agentFireOrg??null,org=named??hireOrg(),orgName=t.closest('[data-agent-fire-name]')?.dataset.agentFireName??named;
if(t.hasAttribute('data-agent-fire')){const name=t.dataset.agentFire;fireAsk=fireKey(org,name);t.outerHTML=fireConfirm(name,named,orgName);document.querySelector(fireSel('data-agent-fire-yes',name,named))?.focus();}
else if(t.hasAttribute('data-agent-fire-no')){const name=t.dataset.agentFireNo;fireAsk=null;t.closest('[data-agent-fire-confirm]').outerHTML=fireButton(name,named,orgName);document.querySelector(fireSel('data-agent-fire',name,named))?.focus();announce('Cancelled. Nothing was fired.');}
else void fireAgent(t.dataset.agentFireYes,named,orgName);
});
window.MosaicDecide=Object.freeze({fireControl,fireNote});
document.addEventListener('click',e=>{if(e.target.closest?.('[data-hire-load]'))hireSubmit(true);});
document.addEventListener('submit',e=>{if(e.target.id==='hire-start-form'){e.preventDefault();hireSubmit();}});
const answerChoices = c => ['decision','hire'].includes(c.kind)
@@ -523,6 +604,9 @@
};
const decideRefusal = (res, json, fallback) => res && !res.ok && res.status !== 408 && typeof json?.error === 'string' && typeof json?.message === 'string'
? { code: json.error, message: json.message } : { code: fallback, message: DECIDE_FALLBACK[fallback] };
// SP3: an answer started from the system Inbox names its organization and goes there, whichever
// organization was opened last. One started on a decision page keeps the page's own scope.
const decideBase = a => a.org ? `/api/orgs/${enc(a.org)}` : '/api';
async function decide(step) {
const a = answer;
if (!a || a.pending || a.result) return;
@@ -533,7 +617,7 @@
const choice = selected.key, ordinary = ['decision','hire'].includes(a.console.kind);
const adjust=choice==='yes'?collectHireAdjustment(a.console):undefined;
a.pending = step; a.error = null; a.confirm = null; paintDecide();
const { res, json } = await decidePost(`/api/decisions/${enc(a.id)}/confirmation`, { choice,...(adjust===undefined?{}:{adjust}) });
const { res, json } = await decidePost(`${decideBase(a)}/decisions/${enc(a.id)}/confirmation`, { choice,...(adjust===undefined?{}:{adjust}) });
a.pending = null;
// The page moved to another decision meanwhile: its confirmation is dropped, never shown.
if (answer !== a) { if (res?.type === 'opaqueredirect') signOut(); return; }
@@ -547,7 +631,7 @@
if (step !== 'confirm' || !a.confirm) return;
const c = a.confirm;
a.pending = 'confirm'; a.error = null; paintDecide();
const { res, json } = await decidePost(`/api/decisions/${enc(a.id)}/resolve`, { choice: c.choice, confirmation: c.confirmation });
const { res, json } = await decidePost(`${decideBase(a)}/decisions/${enc(a.id)}/resolve`, { choice: c.choice, confirmation: c.confirmation });
// One use, whatever came back.
a.pending = null; a.confirm = null;
if (answer !== a) { if (res?.type === 'opaqueredirect') signOut(); else render(false); return; }
@@ -557,6 +641,53 @@
paintDecide('#decide-status'); announce(['decision','hire'].includes(c.kind) ? 'Recorded' : c.action === 'approve' ? 'Approved' : 'Denied'); render(false);
} else { a.error = decideRefusal(res, json, 'outcome-unknown'); paintDecide('#decide-status'); announce(`Not answered: ${a.error.message}`); }
}
// Whether this Console decides in one organization, from that organization's own config: the system
// Inbox's hire links must not follow the organization opened last, whose bus may be the stopped one.
const orgConfig = id => (isTester ? Promise.resolve(null) : fetch(`/api/orgs/${enc(id)}/config`, { cache: 'no-store', redirect: 'manual' })
.then(r => (r.ok ? r.json() : null)).catch(() => null));
const decidesIn = id => orgConfig(id).then(c => c?.decide === true && c?.tester !== true);
// SP4: whether this Console takes task changes in one organization, from that organization's own
// config (orgSetup, as the per-organization board read it), so the system task board offers a move
// only where the row's organization takes it.
const tasksIn = id => orgConfig(id).then(c => c?.orgSetup === true && c?.tester !== true);
// SP3: the answer panel for the row selected in the Inbox, in that row's organization. That
// organization's config says whether this Console answers decisions there, and its bus inbox says
// whether this decision is eligible (its `console` field), so neither comes from the organization
// opened last. The state follows the same keep rules as the decision page's. `current` is the
// render's own check: a read that returns after the page moved on changes nothing.
async function inboxAnswer(d, current) {
if (!d || isTester || !d.console || typeof d.org !== 'string') return inboxKeep(d);
const base = `/api/orgs/${enc(d.org)}`;
let eligible = null, failed = false, seen = null;
try {
const [c, i] = await Promise.all([`${base}/config`, `${base}/bus/inbox`].map(u => fetch(u, { cache: 'no-store', redirect: 'manual' })));
if (c.type === 'opaqueredirect' || i.type === 'opaqueredirect') { if (current()) signOut(); return ''; }
if (!c.ok || !i.ok) throw new Error('not read');
const [cfg, box] = await Promise.all([c.json(), i.json()]);
const row = (Array.isArray(box?.rows) ? box.rows : []).find(r => r?.id === d.id);
// The broker's inbox row is the decisions row (`route_to`) plus `authorization`; the confirm
// step shows who raised it and what it affects from it, as the decision page does from the trail.
eligible = cfg?.decide === true && cfg?.tester !== true && row?.route_to === 'human' && row.console && typeof row.console === 'object' ? row.console : null;
if (eligible) seen = { at: row.at, raisedBy: { role: row.raised_by_role, run: row.raised_by_run }, routeTo: row.route_to, authorization: row.authorization ?? null };
} catch { failed = true; }
if (!current()) return '';
const same = answer?.org === d.org && answer.id === d.id;
if (!same) answer = eligible ? { id: d.id, org: d.org, console: eligible, pending: null, confirm: null, error: null, result: null } : null;
else if (eligible && !answer.pending) {
if (answer.console.digest !== eligible.digest) answer.confirm = null;
answer.console = eligible;
}
else if (!eligible && !failed && !answer.pending && !answer.result) answer = null;
if (answer?.org === d.org && answer.id === d.id) { if (seen) answer.decision = seen; return decideHtml(); }
return failed ? '<p class="note" data-ws-answer-why>Whether this Console can answer it here was not read: the organization did not answer. Open it in its organization, or use a terminal.</p>' : '';
}
// A row this Console cannot answer drops any answer held for another row, unless one is in flight.
function inboxKeep(d) {
if (answer?.org && !answer.pending && !(d && answer.org === d.org && answer.id === d.id && answer.result)) answer = null;
return answer?.org && d && answer.org === d.org && answer.id === d.id ? decideHtml() : '';
}
// The receipt stays on screen after the answered row leaves the list.
const inboxAnswered = key => answer?.org && answer.result && `${answer.org}:${answer.id}` === key ? decideHtml() : '';
async function inboxView(get) {
await configRead;
if(!hireDraft.business && window.MosaicOrg?.id)hireDraft.business=window.MosaicOrg.id;
@@ -578,7 +709,7 @@
if (after !== null && !SAFE.test(after)) return notFound('The message cursor is not a message id.');
const page = await get('messages', after === null ? undefined : after);
const body = page.rows.length ? `<ul id="message-list" class="waiting s1-replies">${page.rows.map(m =>
`<li class="wait-item"><p class="small muted">${txt(m.from_role)} · ${txt(m.class)} · ${when(m.at)} · ${m.read ? 'Read' : 'Unread'} · <a href="#/trail/message/${enc(m.id)}">trail</a></p><p class="s1-message">${messageText(m)}</p></li>`).join('')}</ul>`
`<li class="wait-item"><p class="small muted">${txt(m.from_role)} · ${txt(classWord(m.class))} · ${when(m.at)} · ${m.read ? 'Read' : 'Unread'} · <a href="#/trail/message/${enc(m.id)}">trail</a></p><p class="s1-message">${messageText(m)}</p></li>`).join('')}</ul>`
: empty('No messages to you.', 'Messages appear here as the bus is read.');
return `${head('Messages', `${readNote(get)} Every message to you, newest first. Reading here marks nothing read.`)}
<p class="small muted">${page.total} messages · ${page.unread} unread</p>${body}
@@ -771,12 +902,15 @@
return `<section aria-labelledby="b-thread-claims">${title}<div class="banner err" role="alert"><p>${why(err)}</p>${retry}</div></section>`;
}
}
async function agentsView(get) {
// SP5: an organization's scoped page leads with its rows of the system Agents table (which owns the
// heading), then the levels grid under its own h2, then held roles and threads.
const scopedTop = async (q, org, note) => `${await window.MosaicWorkspace.agentsPage(q, { scope: org })}${await window.MosaicWorkspace.agentGrid(note, undefined, { under: true })}`;
async function agentsView(get, q = new URLSearchParams(), org = null) {
let claims;
try { claims = await get('agents'); } catch (err) {
if (!window.MosaicOrg || err.code === 'signed-out') throw err;
if (refusal(err)) forget();
return `${await window.MosaicWorkspace.agentGrid()}<div class="banner err" role="alert">The selected organization's held roles could not be read. ${why(err)}</div>`;
return `${org ? await scopedTop(q, org) : await window.MosaicWorkspace.agentGrid()}<div class="banner err" role="alert">The selected organization's held roles could not be read. ${why(err)}</div>`;
}
let instances = null, threads = [];
if (!isTester) {
@@ -793,7 +927,7 @@
const threadSection = await threadClaimsSection(get, holders, threads, !!instances, running);
const rows = claims.map(c => `<tr><th scope="row">${txt(c.role)}</th><td>${stateMark(c.state)}${c.working ? `<span class="source">${esc(plural(c.working.messages, 'message'))} since ${when(c.working.since)}</span>` : ''}</td><td>${attention(c)}</td><td>${txt(holders.get(c.holder_run) || c.role)}<span class="source">run ${txt(c.holder_run)}${!instances ? ', running status unavailable' : running.has(c.holder_run) ? '' : ', not running'}</span></td><td>${txt(c.harness)}${c.address ? `<span class="source">${txt(c.address)}</span>` : ''}</td><td>${when(c.at)}</td></tr>`).join('');
// Organization mode (sample 08): the levels grid carries the page heading; held roles follow.
const top = window.MosaicOrg ? await window.MosaicWorkspace.agentGrid(readNote(get)) : head('Agents', readNote(get));
const top = !window.MosaicOrg ? head('Agents', readNote(get)) : org ? await scopedTop(q, org, readNote(get)) : await window.MosaicWorkspace.agentGrid(readNote(get));
return `${top}
<section aria-labelledby="b-claims"><h2 id="b-claims">Held roles <span class="count">${claims.length}</span></h2><p class="small muted">The current holder of each claimed role. A role nobody holds does not appear. Working: the holder has messages it received and hasn't answered yet. Waiting: a decision the role raised is open in your inbox. Otherwise idle.</p>
${claims.length ? `<div class="table-wrap" tabindex="0" role="region" aria-label="Held roles, scroll for all columns"><table class="s1-table s1-agents"><thead><tr>${['Role', 'State', 'Attention', 'Holder', 'Harness', 'Held since'].map(h => `<th scope="col">${h}</th>`).join('')}</tr></thead><tbody>${rows}</tbody></table></div>` : empty('No role is held right now.', 'A role shows here while a run holds its claim on the bus.')}</section>
@@ -989,9 +1123,9 @@
document.addEventListener('change',e=>{const form=e.target.closest?.('#launch-settings-form');if(form){settingsInputs=settingDraft(form);markSettingsDraft('limits',true);form.querySelector('.settings-actions')?.classList.add('has-draft');const discard=$('launch-settings-reload');if(discard)discard.hidden=false;}});
document.addEventListener('click',e=>{if(e.target.id!=='launch-settings-reload')return;settingsInputs=null;settingsSnapshot=null;settingsReceipt='';last.delete('api:settings');render(true);});
document.addEventListener('submit',async e=>{
if(e.target.id!=='launch-settings-form')return;e.preventDefault();if(!canSend||out()||settingsSaving)return;settingsInputs=settingDraft(e.target);let payload;try{payload=settingPayload();}catch(err){settingsReceipt=err.message+' Draft kept.';render(false);return;}settingsSaving=true;settingsReceipt='';render(false);
try{const response=await fetch('/api/settings',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(payload),cache:'no-store',redirect:'manual'});if(response.type==='opaqueredirect'){settingsReceipt='Sign in again. Draft kept.';signOut();}else{const result=await response.json();if(response.ok&&/^[a-f0-9]{64}$/.test(result?.revision??'')){settingsInputs=null;settingsSnapshot=result;const prior=last.get('api:settings');if(prior)last.set('api:settings',{...prior,launch:result});settingsReceipt='Launch settings saved.';}else settingsReceipt=result?.sent==='unknown'?'Outcome unknown. Read current settings before trying again. Draft kept.':`${result?.message||'Settings refused.'} Draft kept.`;}}
catch{settingsReceipt='Outcome unknown. Read current settings before trying again. Draft kept.';}finally{settingsSaving=false;if(!out())render(false);}
if(e.target.id!=='launch-settings-form')return;e.preventDefault();if(!canSend||out()||settingsSaving)return;settingsInputs=settingDraft(e.target);let payload;try{payload=settingPayload();}catch(err){settingsReceipt=err.message+' Draft kept.';render(false);return;}settingsSaving=true;settingsReceipt='';render(false);const epoch=orgEpoch;
try{const response=await fetch('/api/settings',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(payload),cache:'no-store',redirect:'manual'});if(epoch!==orgEpoch){if(response.type==='opaqueredirect')signOut();return;}if(response.type==='opaqueredirect'){settingsReceipt='Sign in again. Draft kept.';signOut();}else{const result=await response.json();if(epoch!==orgEpoch)return;if(response.ok&&/^[a-f0-9]{64}$/.test(result?.revision??'')){settingsInputs=null;settingsSnapshot=result;const prior=last.get('api:settings');if(prior)last.set('api:settings',{...prior,launch:result});settingsReceipt='Launch settings saved.';}else settingsReceipt=result?.sent==='unknown'?'Outcome unknown. Read current settings before trying again. Draft kept.':`${result?.message||'Settings refused.'} Draft kept.`;}}
catch{if(epoch!==orgEpoch)return;settingsReceipt='Outcome unknown. Read current settings before trying again. Draft kept.';}finally{if(epoch===orgEpoch){settingsSaving=false;if(!out())render(false);}}
});
// Row 125 (#1619, REQ-LIMIT-3, REQ-LIMIT-4): each token limit as the bus's checks report it. A
// limit no switched-on check counts reads "not enforced". Reset counts it again from now. Row 126
@@ -1012,9 +1146,9 @@
document.addEventListener('click',async e=>{
const path=e.target.dataset?.limitReset;if(path===undefined||!canSend||out()||settingsSaving)return;
const revision=settingsSnapshot?.revision;if(!/^[a-f0-9]{64}$/.test(revision??''))return;
settingsSaving=true;resetReceipt='';render(false);let reread=false;
try{const response=await fetch('/api/settings',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({revision,reset:[JSON.parse(path)]}),cache:'no-store',redirect:'manual'});if(response.type==='opaqueredirect'){resetReceipt='Sign in again.';signOut();}else{const result=await response.json();if(response.ok&&/^[a-f0-9]{64}$/.test(result?.revision??'')){settingsSnapshot=result;const prior=last.get('api:settings');if(prior)last.set('api:settings',{...prior,launch:result});reread=true;resetReceipt='Limit reset.';}else resetReceipt=result?.sent==='unknown'?'Outcome unknown. Read current settings before trying again.':`${result?.message||'Reset refused.'}`;}}
catch{resetReceipt='Outcome unknown. Read current settings before trying again.';}finally{settingsSaving=false;if(!out())render(reread);}
settingsSaving=true;resetReceipt='';render(false);let reread=false;const epoch=orgEpoch;
try{const response=await fetch('/api/settings',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({revision,reset:[JSON.parse(path)]}),cache:'no-store',redirect:'manual'});if(epoch!==orgEpoch){if(response.type==='opaqueredirect')signOut();return;}if(response.type==='opaqueredirect'){resetReceipt='Sign in again.';signOut();}else{const result=await response.json();if(epoch!==orgEpoch)return;if(response.ok&&/^[a-f0-9]{64}$/.test(result?.revision??'')){settingsSnapshot=result;const prior=last.get('api:settings');if(prior)last.set('api:settings',{...prior,launch:result});reread=true;resetReceipt='Limit reset.';}else resetReceipt=result?.sent==='unknown'?'Outcome unknown. Read current settings before trying again.':`${result?.message||'Reset refused.'}`;}}
catch{if(epoch!==orgEpoch)return;resetReceipt='Outcome unknown. Read current settings before trying again.';}finally{if(epoch===orgEpoch){settingsSaving=false;if(!out())render(reread);}}
});
function tokenUsage(value) {
if (!value?.total) return '<section class="panel" aria-labelledby="token-usage-title"><h2 id="token-usage-title">Token usage</h2><p>Usage unavailable. No count was read.</p></section>';
@@ -1069,9 +1203,9 @@
}
const unknownAssistant='Outcome unknown. Read current settings before trying again. Draft kept.';
async function assistantPost(url,payload,instance,ok,kind='tester'){
if(kind==='tester')assistantBusy=true;else assistantFormsBusy.add(assistantKey(instance,kind));assistantReceiptKinds[instance]=kind;assistantReceipts[instance]='';if(kind!=='tester')assistantCardReceipts[assistantKey(instance,kind)]='';render(false);
try{const response=await fetch(url,{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(payload),cache:'no-store',redirect:'manual'});if(response.type==='opaqueredirect'){assistantReceipts[instance]='Sign in again. Draft kept.';signOut();}else{const result=await response.json();assistantReceiptKinds[instance]=kind;assistantReceipts[instance]=response.ok?ok(result):result?.sent==='unknown'?unknownAssistant:`${result?.message||'Refused.'} Draft kept.`;}}
catch{assistantReceiptKinds[instance]=kind;assistantReceipts[instance]=unknownAssistant;}finally{if(kind==='tester')assistantBusy=false;else{assistantCardReceipts[assistantKey(instance,kind)]=assistantReceipts[instance];assistantFormsBusy.delete(assistantKey(instance,kind));}if(!out())render(false);}
if(kind==='tester')assistantBusy=true;else assistantFormsBusy.add(assistantKey(instance,kind));assistantReceiptKinds[instance]=kind;assistantReceipts[instance]='';if(kind!=='tester')assistantCardReceipts[assistantKey(instance,kind)]='';render(false);const epoch=orgEpoch;
try{const response=await fetch(url,{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(payload),cache:'no-store',redirect:'manual'});if(epoch!==orgEpoch){if(response.type==='opaqueredirect')signOut();return;}if(response.type==='opaqueredirect'){assistantReceipts[instance]='Sign in again. Draft kept.';signOut();}else{const result=await response.json();if(epoch!==orgEpoch)return;assistantReceiptKinds[instance]=kind;assistantReceipts[instance]=response.ok?ok(result):result?.sent==='unknown'?unknownAssistant:`${result?.message||'Refused.'} Draft kept.`;}}
catch{if(epoch!==orgEpoch)return;assistantReceiptKinds[instance]=kind;assistantReceipts[instance]=unknownAssistant;}finally{if(epoch===orgEpoch){if(kind==='tester')assistantBusy=false;else{assistantCardReceipts[assistantKey(instance,kind)]=assistantReceipts[instance];assistantFormsBusy.delete(assistantKey(instance,kind));}if(!out())render(false);}}
}
const assistantForm=el=>el?.closest?.('.assistant-form');
for(const kind of ['input','change'])document.addEventListener(kind,e=>{const form=assistantForm(e.target);if(!form)return;const instance=form.dataset.instance,field=e.target.dataset.assistantField;if(field==='name')nameDrafts[instance]=e.target.value;else if(field)assistantDrafts[instance]={...Object.fromEntries(['definition','vars','tracker'].map(f=>[f,form.querySelector(`[data-assistant-field="${f}"]`).value]))};if(field){markSettingsDraft('assistant',true);form.querySelector('.settings-actions')?.classList.add('has-draft');const discard=form.querySelector('[data-assistant-discard]');if(discard)discard.hidden=false;}});
@@ -1136,11 +1270,11 @@
const form=e.target?.closest?.('.instance-form');if(!form||e.target!==form)return;e.preventDefault();if(!(canSend || isTester)||out()||!instanceView)return;
const op=form.dataset.op;if(instanceBusyOps.has(op))return;instanceReceiptOp=op;instanceDrafts[op]=instanceFields(form);let payload;
try{payload=instancePayload(op,instanceDrafts[op]);}catch(err){instanceReceipt=err.message;instanceReceipts[op]=instanceReceipt;render(false);return;}
instanceBusyOps.add(op);instanceReceipt='';instanceReceipts[op]='';render(false);
try{const response=await fetch('/api/instances',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(payload),cache:'no-store',redirect:'manual'});if(response.type==='opaqueredirect'){instanceReceipt='Sign in again. Draft kept.';signOut();}else{const result=await response.json();
instanceBusyOps.add(op);instanceReceipt='';instanceReceipts[op]='';render(false);const epoch=orgEpoch;
try{const response=await fetch('/api/instances',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(payload),cache:'no-store',redirect:'manual'});if(epoch!==orgEpoch){if(response.type==='opaqueredirect')signOut();return;}if(response.type==='opaqueredirect'){instanceReceipt='Sign in again. Draft kept.';signOut();}else{const result=await response.json();if(epoch!==orgEpoch)return;
if(response.ok&&instanceAnswer(result)){instanceDrafts[op]=null;instanceView=result;const prior=last.get('instances');if(prior)last.set('instances',{...prior,rows:[result]});instanceReceipt=`${op==='add'?'Added':'Changed'} ${payload.instance}. ${result.restart?restartText():NO_RESTART_TEXT}`;}
else instanceReceipt=response.ok||result?.sent==='unknown'?unknownInstance:`${result?.message||'Refused.'} Draft kept.`;}}
catch{instanceReceipt=unknownInstance;}finally{instanceBusyOps.delete(op);instanceReceiptOp=op;instanceReceipts[op]=instanceReceipt;if(!out())render(false);}
catch{if(epoch!==orgEpoch)return;instanceReceipt=unknownInstance;}finally{if(epoch===orgEpoch){instanceBusyOps.delete(op);instanceReceiptOp=op;instanceReceipts[op]=instanceReceipt;if(!out())render(false);}}
});
// Row 65 (mos-0840): the routing table. One row per instance: harness, model and thinking, and
// the fallback's three. Each cell offers the switched-on harnesses, the model table's keys and the
@@ -1166,8 +1300,8 @@
const routesApplyMarkup=()=>routesApply?.length?`<ul class="routes-apply" aria-label="How the change reaches each agent">${routesApply.map(a=>`<li><b>${txt(a.name)}</b>: ${txt(a.text)}${a.restart&&canSend&&!isTester?` ${window.MosaicAgents?.restartMarkup(a.name,a.thread)??''}`:''}</li>`).join('')}</ul>`:'';
let harnessSettings=null, harnessDraft=null, harnessLoading=false, harnessReceipt='', harnessBusy=false;
function readHarnesses(){
if(harnessLoading || harnessSettings !== null || !canSend || isTester)return; harnessLoading=true;
fetch('/api/proxy/plugins',{cache:'no-store',redirect:'manual'}).then(async r=>{const v=await r.json();if(!r.ok || !/^[a-f0-9]{64}$/.test(v.revision??'') || !Array.isArray(v.available?.harness) || !v.available.harness.every(n=>typeof n==='string') || !Array.isArray(v.plugins?.harness??[]))throw Error();harnessSettings=v;}).catch(()=>{harnessSettings=false;harnessReceipt='Harnesses could not be read.';}).finally(()=>{harnessLoading=false;if(routeOf().split('?')[0]==='/settings/routing')render(false);});
if(harnessLoading || harnessSettings !== null || !canSend || isTester)return; harnessLoading=true;const epoch=orgEpoch;
fetch('/api/proxy/plugins',{cache:'no-store',redirect:'manual'}).then(async r=>{const v=await r.json();if(epoch!==orgEpoch)return;if(!r.ok || !/^[a-f0-9]{64}$/.test(v.revision??'') || !Array.isArray(v.available?.harness) || !v.available.harness.every(n=>typeof n==='string') || !Array.isArray(v.plugins?.harness??[]))throw Error();harnessSettings=v;}).catch(()=>{if(epoch!==orgEpoch)return;harnessSettings=false;harnessReceipt='Harnesses could not be read.';}).finally(()=>{if(epoch!==orgEpoch)return;harnessLoading=false;if(routeOf().split('?')[0]==='/settings/routing')render(false);});
}
const ROUTE_CELLS=[['harness','Harness'],['model','Model'],['thinking','Thinking'],['fallback.harness','Fallback harness'],['fallback.model','Fallback model'],['fallback.thinking','Fallback thinking']];
const routeCells=r=>({harness:r.harness??'',model:r.model??'',thinking:r.thinking??'','fallback.harness':r.fallback?.harness??'','fallback.model':r.fallback?.model??'','fallback.thinking':r.fallback?.thinking??''});
@@ -1200,7 +1334,7 @@
// fixture-only catalogue is ready with no model proxy). Before the setting is read it falls
// back to the catalogue status, as before.
const proxyOn=harnessSettings?(Array.isArray(harnessSettings.plugins?.['model-provider'])?harnessSettings.plugins['model-provider']:[]).includes('cliproxy'):v.catalogue?.status!=='disabled';
const catalogueInfo=v.catalogue?.status==='ready'?`<p class="small muted">Model catalogue, observed ${txt(window.MosaicLocalTime(v.catalogue.observedAt))}.</p>${(v.catalogue.notices??[]).map(n=>`<p class="small warn">${txt(n)}</p>`).join('')}`:v.catalogue?.status==='unavailable'?`<p class="small warn">Model catalogue unavailable. A change to thinking alone still saves.${proxyOn&&canSend&&!isTester?' A new model needs the catalogue: set up the model proxy, or, when this organization has none, press Disable model proxy catalogue.':''}</p>`:'<p class="small muted">Model catalogue not enabled.</p>';
const catalogueInfo=v.catalogue?.status==='ready'?`<p class="small muted">Model catalogue, observed ${txt(window.MosaicLocalTime(v.catalogue.observedAt))}.</p>${(v.catalogue.notices??[]).map(n=>`<p class="small warn">${txt(n)}</p>`).join('')}`:v.catalogue?.status==='unavailable'?`<p class="small warn">Model catalogue unavailable. A change to thinking alone still saves.${proxyOn&&canSend&&!isTester?' A new model needs the catalogue: set up the model proxy, or, when this organization has none, press Disable model proxy catalogue.':''}</p>${(v.catalogue.notices??[]).map(n=>`<p class="small warn">${txt(n)}</p>`).join('')}`:'<p class="small muted">Model catalogue not enabled.</p>';
const providerControl=canSend&&!isTester?`<button type="button" id="provider-switch" data-enabled="${proxyOn}">${proxyOn?'Disable':'Enable'} model proxy catalogue</button><p role="status" id="provider-switch-status"></p>`:'';
const harnessControl=canSend&&!isTester?`<fieldset class="harness-control"><legend>Harnesses</legend>${harnessSettings ? [...new Set([...harnessSettings.available.harness,...(harnessSettings.plugins.harness??[])])].map(name=>`<label><input type="checkbox" data-harness="${esc(name)}"${(harnessDraft??harnessSettings.plugins.harness??[]).includes(name)?' checked':''}${harnessBusy?' disabled':''}> ${txt(name)}</label>`).join('')+` <button type="button" id="harness-save"${harnessBusy?' disabled':''}>Save harnesses</button>` : '<p>Harnesses unavailable.</p><button type="button" id="harness-read">Read harnesses again</button>'}<p role="status" id="harness-status">${txt(harnessReceipt)}</p></fieldset>`:'';
const off=v.harnesses.length?'':'<p class="small warn">No harness is switched on in the business file\'s plugins.harness, so every launch refuses harness-off and a save that changes a harness refuses too. Switch one on under Harnesses.</p>';
@@ -1244,32 +1378,32 @@
if(harnessSettings.revision!==routesView?.revision){harnessReceipt='The business changed. Reload this page before saving harnesses.';render(false);return;}
const used=old.filter(n=>!selected.includes(n) && Object.values(routesView.instances).some(r=>r.harness===n || r.fallback?.harness===n));
if(used.length){harnessReceipt=`A saved route uses ${used.join(', ')}. Change the route before switching it off.`;render(false);return;}
harnessBusy=true;const button=e.target;button.disabled=true;harnessReceipt='';
try{const response=await fetch('/api/proxy/plugins/set',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({revision:harnessSettings.revision,plugins:{harness:selected}}),cache:'no-store',redirect:'manual'});const result=await response.json();if(!response.ok){harnessReceipt=result.message||result.error||'Harness setting was refused.';return;}harnessSettings={...result,available:harnessSettings.available};harnessDraft=null;harnessReceipt='Harnesses saved. The next launch uses the new settings.';routesView=null;last.delete('routes');}
catch{harnessReceipt='Outcome unknown. Read the harnesses again before trying.';harnessSettings=false;}
finally{harnessBusy=false;if(!out())render(false);}
harnessBusy=true;const button=e.target;button.disabled=true;harnessReceipt='';const epoch=orgEpoch;
try{const response=await fetch('/api/proxy/plugins/set',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({revision:harnessSettings.revision,plugins:{harness:selected}}),cache:'no-store',redirect:'manual'});const result=await response.json();if(epoch!==orgEpoch)return;if(!response.ok){harnessReceipt=result.message||result.error||'Harness setting was refused.';return;}harnessSettings={...result,available:harnessSettings.available};harnessDraft=null;harnessReceipt='Harnesses saved. The next launch uses the new settings.';routesView=null;last.delete('routes');}
catch{if(epoch!==orgEpoch)return;harnessReceipt='Outcome unknown. Read the harnesses again before trying.';harnessSettings=false;}
finally{if(epoch===orgEpoch){harnessBusy=false;if(!out())render(false);}}
});
document.addEventListener('click',async e=>{if(e.target.id!=='provider-switch'||!canSend||isTester)return;
const button=e.target,status=$('provider-switch-status');if(routesDraft){status.textContent='Save or discard the route draft first.';return;}button.disabled=true;
try {const read=await fetch('/api/proxy/plugins',{cache:'no-store'});const settings=await read.json();if(!read.ok||!/^[a-f0-9]{64}$/.test(settings.revision??''))throw Error('Could not read provider settings.');
const button=e.target,status=$('provider-switch-status');if(routesDraft){status.textContent='Save or discard the route draft first.';return;}button.disabled=true;const epoch=orgEpoch;
try {const read=await fetch('/api/proxy/plugins',{cache:'no-store'});const settings=await read.json();if(epoch!==orgEpoch)return;if(!read.ok||!/^[a-f0-9]{64}$/.test(settings.revision??''))throw Error('Could not read provider settings.');
const names=Array.isArray(settings.plugins?.['model-provider'])?settings.plugins['model-provider']:[];
// The fresh read decides: a stale label never turns the proxy module on when it meant off.
const on=names.includes('cliproxy');if(String(on)!==button.dataset.enabled){button.dataset.enabled=String(on);button.textContent=`${on?'Disable':'Enable'} model proxy catalogue`;button.disabled=false;status.textContent='The switch now shows the current setting. Press it again to change it.';return;}
const next=on?names.filter(n=>n!=='cliproxy'):[...names,'cliproxy'];
const response=await fetch('/api/proxy/plugins/set',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({revision:settings.revision,plugins:{'model-provider':next}}),cache:'no-store',redirect:'manual'});
if(!response.ok)throw Error('Provider setting was refused.');harnessSettings=null;routesView=null;last.delete('routes');render(true);
}catch(error){status.textContent=error.message;button.disabled=false;}
if(epoch!==orgEpoch)return;if(!response.ok)throw Error('Provider setting was refused.');harnessSettings=null;routesView=null;last.delete('routes');render(true);
}catch(error){if(epoch!==orgEpoch)return;status.textContent=error.message;button.disabled=false;}
});
document.addEventListener('click',e=>{if(e.target.matches?.('.fallback-toggle'))e.target.closest('tr')?.classList.add('fallback-open');});
document.addEventListener('click',e=>{if(e.target.id!=='routes-reload')return;routesDraft=null;routesView=null;routesReceipt='';routesApply=null;last.delete('routes');render(true);});
document.addEventListener('submit',async e=>{
if(e.target.id!=='routes-form')return;e.preventDefault();if(!(canSend || isTester)||out()||routesBusy||!routesView)return;
routesDraft=routesFields(e.target);let payload;try{payload=routesPayload(routesDraft);}catch(err){routesReceipt=err.message;render(false);return;}
routesBusy=true;routesReceipt='';routesApply=null;render(false);
try{const response=await fetch('/api/routes',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(payload),cache:'no-store',redirect:'manual'});if(response.type==='opaqueredirect'){routesReceipt='Sign in again. Draft kept.';signOut();}else{const result=await response.json();
if(response.ok&&routesAnswer(result)){routesDraft=null;routesView=result;harnessSettings=null;const prior=last.get('routes');if(prior)last.set('routes',{...prior,rows:[result]});routesReceipt=`Routes saved for ${Object.keys(payload.routes).join(', ')}. The next launch of each uses the new route.`;routesApply=await routesApplyRead(Object.keys(payload.routes));}
routesBusy=true;routesReceipt='';routesApply=null;render(false);const epoch=orgEpoch;
try{const response=await fetch('/api/routes',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(payload),cache:'no-store',redirect:'manual'});if(epoch!==orgEpoch){if(response.type==='opaqueredirect')signOut();return;}if(response.type==='opaqueredirect'){routesReceipt='Sign in again. Draft kept.';signOut();}else{const result=await response.json();if(epoch!==orgEpoch)return;
if(response.ok&&routesAnswer(result)){routesDraft=null;routesView=result;harnessSettings=null;const prior=last.get('routes');if(prior)last.set('routes',{...prior,rows:[result]});routesReceipt=`Routes saved for ${Object.keys(payload.routes).join(', ')}. The next launch of each uses the new route.`;const applied=await routesApplyRead(Object.keys(payload.routes));if(epoch!==orgEpoch)return;routesApply=applied;}
else routesReceipt=response.ok||result?.sent==='unknown'?unknownRoutes:`${result?.message||'Refused.'}${catalogueStep(result?.error,payload.routes)} Draft kept.`;}}
catch{routesReceipt=unknownRoutes;}finally{routesBusy=false;if(!out())render(false);}
catch{if(epoch!==orgEpoch)return;routesReceipt=unknownRoutes;}finally{if(epoch===orgEpoch){routesBusy=false;if(!out())render(false);}}
});
// Row 194 (#1692, D7): the Agents section lives in agents.js (window.MosaicAgents) and draws from
// the same instances read. A refresh drops that read so the next render asks the bus again.
@@ -1297,13 +1431,13 @@
});
});
// Organizations is writable when the server allows org setup, which it does in organization mode where send is off.
const readonlyPage = page => !['appearance','business','console'].includes(page) && !(page === 'organizations' && orgSetup) && !canSend && !isTester;
const settingsPages = [['appearance','Appearance'],['business',window.MosaicOrg ? 'Organization' : 'Business'],['limits','Launch limits'],['organizations','Organizations'],['routing','Routing'],['agents','Agents'],['assistant','Assistant'],['tokens','Token use'],['model-proxy','Model proxy'],['console','Console'],['about','About']];
const readonlyPage = page => !['appearance','business','console','triage'].includes(page) && !(page === 'organizations' && orgSetup) && !canSend && !isTester;
const settingsPages = [['appearance','Appearance'],['business',window.MosaicOrg ? 'Organization' : 'Business'],['limits','Launch limits'],['organizations','Organizations'],['routing','Routing'],['agents','Agents'],['assistant','Assistant'],['tokens','Token use'],['model-proxy','Model proxy'],['triage','Triage'],['console','Console'],['about','About']];
function markSettingsDraft(page,dirty){const link=document.querySelector(`#settings-nav a[href="#/settings/${page}"]`), dot='<span class="settings-dot"><span class="sr-only">unsaved changes</span></span>';if(link && dirty && !link.querySelector('.settings-dot'))link.insertAdjacentHTML('beforeend',dot);const button=$('settings-disclosure');if(dirty && link?.getAttribute('aria-current')==='page' && button && !button.querySelector('.settings-dot'))button.querySelector('strong').insertAdjacentHTML('beforeend',dot);}
function settingsShell(page, body, helper='') {
const pages=isTester ? [['appearance','Appearance'],['business','Business'],['routing','Routing'],['agents','Agents'],['names','Seat names']] : settingsPages;
const pages=isTester ? [['appearance','Appearance'],['business','Business'],['routing','Routing'],['agents','Agents'],['names','Seat names']] : settingsPages.filter(([id])=>id!=='triage'||triageOwner);
const label=pages.find(([id])=>id===page)?.[1] || 'Appearance';
const isDirty=id=>(id==='routing'&&routesDraft)||(id==='limits'&&settingsInputs)||(id==='assistant'&&(Object.keys(assistantDrafts).length||Object.keys(nameDrafts).length))||(id==='agents'&&(instanceDrafts.add||instanceDrafts.change||window.MosaicAgentLevels?.hasDraft()));
const isDirty=id=>(id==='routing'&&routesDraft)||(id==='limits'&&settingsInputs)||(id==='assistant'&&(Object.keys(assistantDrafts).length||Object.keys(nameDrafts).length))||(id==='agents'&&(instanceDrafts.add||instanceDrafts.change||window.MosaicAgentLevels?.hasDraft()))||(id==='triage'&&window.MosaicTriageRoute?.hasDraft());
const dot='<span class="settings-dot"><span class="sr-only">unsaved changes</span></span>';
const links=pages.map(([id,name],i)=>`${i===0?'<div class="settings-group">Your browser</div>':i===1?'<div class="settings-group">This instance</div>':''}<a href="#/settings/${id}"${id===page?' aria-current="page"':''}>${name}${isDirty(id)?dot:''}</a>`).join('') + (!isTester ? '<div class="settings-group">Members and invites <span class="muted">not built</span></div>' : '');
return `${head('Settings','Your browser and this instance.')}<div class="settings-layout"><div><button type="button" id="settings-disclosure" aria-expanded="false" aria-controls="settings-nav"><small>Section</small><strong>${label}${isDirty(page)?dot:''}</strong><span aria-hidden="true">⌄</span></button><nav id="settings-nav" aria-label="Settings sections">${links}</nav></div><div class="settings-content settings-${page}${readonlyPage(page)?' readonly':''}"><h2 id="settings-page-title" tabindex="-1">${label}</h2><p class="settings-helper">${helper}</p>${readonlyPage(page)?'<p class="settings-readonly">Read only. Saving requires signed-in send mode.</p>':''}${body}</div></div>`;
@@ -1313,6 +1447,8 @@
if (page==='appearance') return settingsShell(page,appearance(),'These choices apply in this browser only.');
if (page==='organizations') { await configRead; return settingsShell(page,window.MosaicOrgCreate.markup,'Create an organization from the template, edit it, and finish its setup. Each step names the command it equals.'); }
if (page==='model-proxy') { await configRead; return settingsShell(page,window.MosaicProxy.markup,'Accounts used by this instance, their priority, and the client keys assigned to agents.'); }
// #1873 triage-settings: Settings > Triage (triage-settings.js), the instance owner's only; anyone else gets no page.
if (page==='triage') { await configRead; if (!triageOwner || !window.MosaicTriageRoute) return notFound(); return settingsShell(page,await window.MosaicTriageRoute.section(),'The model, harness and daily token cap Triage uses. Only the instance owner sees this page.'); }
// F3: Settings > Console (console-restart.js). The server checks the owner, Origin and trail.
if (page==='console') { await configRead; await window.MosaicConsole?.ready; return settingsShell(page,window.MosaicConsole?.settingsMarkup()??'<section class="panel"><p class="small warn">The Console controls did not load. Reload the page to try again.</p></section>','Restart this Console on the same address and configuration.'); }
const s = await get.api('settings'), n = s.notifier || {};
@@ -1480,6 +1616,7 @@
if (!s || !saveable(s)) return;
const sent = { project: s.project, path: s.path, base: s.commit, content: s.text }, unknown = 'Outcome unknown: the save may have gone through. Copy your text, then reload the file to check before saving again. Draft kept.';
s.saving = true; s.status = '';
const epoch = orgEpoch;
let res = null, body = null;
try {
paintDoc();
@@ -1491,13 +1628,16 @@
} else if (body?.sent === false) s.status = `${typeof body.message === 'string' && body.message ? body.message : 'Not saved.'} Draft kept.`;
else s.status = unknown;
} finally { s.saving = false; } // a throw above must not leave Save off and Reload refused
// #1873 SP1: a switch while this was in flight cleared the drafts; the old file's outcome is not
// painted or announced on the new organization's page.
if (epoch !== orgEpoch) { if (res?.type === 'opaqueredirect') signOut(); return; }
paintDoc();
announce(s.status);
if (res?.type === 'opaqueredirect') signOut();
});
// Not found and states
function notFound(why) { return `${head('Not found')}<div class="empty nf"><b>${why || 'No page at this address.'}</b><p>Nothing is at <code>${txt(location.hash || '#/')}</code>. <a href="#/">Go to the ${window.MosaicOrg ? 'Dashboard' : 'Board'}</a> or press <kbd>Ctrl K</kbd> to search.</p></div>`; }
function notFound(why) { return `${head('Not found')}<div class="empty nf"><b>${why || 'No page at this address.'}</b><p>Nothing is at <code>${txt(location.hash || '#/')}</code>. <a href="${window.MosaicOrg ? '#/dashboard' : '#/'}">Go to the ${window.MosaicOrg ? 'Dashboard' : 'Board'}</a> or press <kbd>Ctrl K</kbd> to search.</p></div>`; }
const loadingView = (source = null) => `${head('Reading…')}<div class="skel-rows" aria-busy="true"><span class="sr-only">${source ? `Reading the ${esc(source.toLowerCase())}.` : 'Reading from the bus.'}</span><span class="skel"></span><span class="skel"></span><span class="skel"></span><span class="skel"></span></div>`;
const retry = '<div class="actions"><button type="button" class="btn" data-retry>Read again</button></div>';
// Why a read failed, in words, with the bus code as given. Never a path or a guess.
@@ -1552,17 +1692,43 @@
const parts = path.split('/').filter(Boolean).map(p => { try { return decodeURIComponent(p); } catch { return null; } });
if (parts.includes(null)) return notFound();
const [a, b, c] = parts, n = parts.length;
if (n === 0 && window.MosaicOrg) return window.MosaicWorkspace.home();
// #1873 SP1: `#/dashboard` is the system dashboard, every organization on one page.
// SP11: with no organization it is still the Dashboard (it says so and offers New organization);
// #/ is then the Console's own board.
if ((n === 0 && window.MosaicOrg) || (a === 'dashboard' && n === 1 && window.MosaicWorkspace)) return window.MosaicWorkspace.home();
if (a === 'projects' && n === 1 && window.MosaicOrg) return window.MosaicWorkspace.projectsPage(q);
if (a === 'organization' && n === 1 && window.MosaicOrg) return window.MosaicWorkspace.dashboard();
if (a === 'inbox' && n === 1 && window.MosaicOrg) return configRead.then(() => window.MosaicWorkspace.inboxPage(q, { hire: hireStartHtml }));
if (a === 'tasks' && n === 1 && window.MosaicOrg) return window.MosaicTasksBoard.view();
if (a === 'organization' && n === 1 && window.MosaicOrg) return window.MosaicWorkspace.dashboard(undefined, { q, configIn: orgConfig });
// SP3: #/inbox is every organization's items; #/orgs/<id>/inbox is that list for one, with its hire form.
if (a === 'inbox' && n === 1 && window.MosaicOrg) {
const scope = /^#\/orgs\/([^/?]+)/.exec(location.hash)?.[1];
let org = null; try { org = scope ? decodeURIComponent(scope) : null; } catch { return notFound(); }
return configRead.then(() => window.MosaicWorkspace.inboxPage(q, { scope: org, hire: org ? hireStartHtml : null, hireIn: org ? null : decidesIn, answer: d => inboxAnswer(d, current), answered: inboxAnswered }));
}
// SP4: #/tasks is every organization's tasks on one board; #/orgs/<id>/tasks is that board for one.
if (a === 'tasks' && n === 1 && window.MosaicOrg) {
const scope = /^#\/orgs\/([^/?]+)/.exec(location.hash)?.[1];
let org = null; try { org = scope ? decodeURIComponent(scope) : null; } catch { return notFound(); }
return configRead.then(() => window.MosaicTasksBoard.view(q, { scope: org, writesIn: tasksIn }));
}
if (a === 'inbox' && n === 1) return inboxView(get);
if (a === 'inbox' && n === 2) return SAFE.test(b) ? decisionView(get, b, current) : notFound(`${txt(b)} is not a decision id.`);
if (a === 'messages' && n === 1) return messagesView(get, q);
if (a === 'tasks' && n === 1) return tasksView(get);
if (a === 'tasks' && n === 2) return TASK.test(b) ? taskView(get, b) : notFound(`${txt(b)} is not a task reference.`);
// SP5: #/agents is every organization's agents; #/orgs/<id>/agents is that table for one, above its levels grid and held roles.
if (a === 'agents' && n === 1 && window.MosaicOrg) {
const scope = /^#\/orgs\/([^/?]+)/.exec(location.hash)?.[1];
let org = null; try { org = scope ? decodeURIComponent(scope) : null; } catch { return notFound(); }
if (!org) return configRead.then(() => window.MosaicWorkspace.agentsPage(q, { scope: null, fireIn: decidesIn, configIn: orgConfig }));
return agentsView(get, q, org);
}
if (a === 'agents' && n === 1) return agentsView(get);
// SP9 (#1873): #/orgs/<id>/workflows lists an organization's workflows; #/orgs/<id>/workflows/<name> draws one, read only.
if (a === 'workflows' && (n === 1 || n === 2) && window.MosaicOrg && window.MosaicWorkflows?.page) {
const scope = /^#\/orgs\/([^/?]+)/.exec(location.hash)?.[1];
let org = null; try { org = scope ? decodeURIComponent(scope) : window.MosaicOrg.id; } catch { return notFound(); }
return org ? window.MosaicWorkflows.page(org, n === 2 ? b : null, q) : notFound();
}
if (a === 'queue' && n === 1) return queueView(get, q);
if (a === 'queue' && n === 2) return /^[1-9]\d{0,5}$/.test(b) ? queueRowView(get, b) : notFound(`${txt(b)} is not a queue row id.`);
if (a === 'settings' && (n === 1 || (n === 2 && [...settingsPages.map(p=>p[0]),'names'].includes(b)))) return settingsView(get, b || 'appearance');
@@ -1577,7 +1743,15 @@
const paused = () => $('pause')?.getAttribute('aria-pressed') === 'true';
// A file open in the editor is never refreshed from under its draft; Reload is the person's to press.
// The cross-organization pages (U3) poll at the workspace read's pollMs.
const wsPage = path => !!window.MosaicOrg && (path === '/' || path === '' || path === '/projects' || path === '/inbox');
// SP12: the organization page repaints in place too when only its query changes (the agent drawer).
const drawerPage = path => wsPage(path) || (path === '/organization' && !!window.MosaicOrg);
// A hash change that only opens, closes or switches the agent drawer is a repaint, not a navigation.
const agentOnly = (from, to) => {
const split = u => { const h = String(u || '').split('#')[1] ?? ''; const [p, q = ''] = h.split('?'); const n = new URLSearchParams(q); const agent = n.get('agent'); n.delete('agent'); n.sort(); return { p, rest: n.toString(), agent }; };
const a = split(from), b = split(to);
return a.p === b.p && a.rest === b.rest && a.agent !== b.agent && /^\/(agents|(orgs\/[^/?]+\/)?organization)$/.test(b.p);
};
const wsPage = path => (path === '/dashboard' && !!window.MosaicWorkspace) || !!window.MosaicOrg && (path === '/' || path === '' || path === '/dashboard' || path === '/projects' || path === '/inbox' || path === '/agents' || path === '/tasks' || /^\/workflows(\/[^/]+)?$/.test(path));
function schedule() { clearTimeout(timer); if (!paused() && !out() && !routeOf().startsWith('/docs/')) timer = setTimeout(() => render(false), wsPage(routeOf().split('?')[0]) ? window.MosaicWorkspace?.pollMs || 10000 : 10000); }
// Keep focus, open <details> and the copy status across a refresh of the same page.
// In the send form, the focused field and its caret too (its values come from `draft`).
@@ -1627,14 +1801,22 @@
// A refresh due while this render reads would replace it: a navigation would lose its heading focus.
clearTimeout(timer);
if (out()) return;
// #1873 SP1: an address with no organization waits for the first list read to pick one, and a
// page drawn right after a switch waits for the new organization's config.
if ((window.MosaicOrg && !window.MosaicOrg.id) || switchRead) {
const g0 = ++gen, waiting = switchRead;
await window.MosaicOrg?.ready; await waiting;
if (waiting && switchRead === waiting) switchRead = null;
if (g0 !== gen || out()) return;
}
const route = routeOf(), [path, query = ''] = route.split('?'), board = window.MosaicOrg ? path === '/board' : path === '/' || path === '' || path === '/board';
// On the cross-organization pages a filter or selection changes only the query: that is a
// repaint of the same page, not a navigation (no loading view, focus and scroll kept).
const samePage = wsPage(path) && typeof shown === 'string' && shown.split('?')[0] === path;
const samePage = drawerPage(path) && typeof shown === 'string' && shown.split('?')[0] === path;
if (path !== '/settings/model-proxy' && proxyCleanup) {proxyCleanup();proxyCleanup=null;}
if ((navigated || path !== '/settings/organizations') && orgCleanup) {orgCleanup();orgCleanup=null;}
// Leaving a decision discards its confirmation immediately, including a preview in flight.
if (answer && (navigated || path !== `/inbox/${answer.id}`)) answer = null;
if (answer && (navigated || path !== (answer.org ? '/inbox' : `/inbox/${answer.id}`))) answer = null;
const g = ++gen, routeVersion = routesEditVersion;
const current = () => g === gen && route === routeOf() && !out();
// In organization mode #/ is the cross-organization dashboard; the processing controls stay on the board.
@@ -1647,13 +1829,17 @@
window.MosaicChat?.leave(chatPath);
if (path === '/business') { location.replace('#/settings/business'); return; }
if (path === '/settings/display') { location.replace('#/settings/appearance'); return; }
// U5: Side by side draws its own two panes (panes.js); every other page stops their polling.
if (path !== '/side-by-side') window.MosaicPanes?.unmount();
else if (window.MosaicOrg && window.MosaicPanes) {
// #1873 SP6: the Assistant page draws its own thread panes (assistant.js); every other page
// stops their polling. It is a system page: an organization's address for it, and the old
// Side by side address, land on `#/assistant`.
if (window.MosaicOrg && window.MosaicAssistant && path === '/side-by-side') { location.replace('#/assistant'); return; }
if (path !== '/assistant') window.MosaicAssistant?.unmount();
else if (window.MosaicOrg && window.MosaicAssistant) {
if (!window.MosaicOrg.system()) { location.replace(`#/assistant${query ? `?${query}` : ''}`); return; }
const fresh = navigated || shown !== path;
shown = path;
if (fresh) { unmountEditor(); await window.MosaicPanes.mount($('bus-view'), query, { navigated }); }
else window.MosaicPanes.refresh();
if (fresh) { unmountEditor(); await window.MosaicAssistant.mount($('bus-view'), query, { navigated }); }
else window.MosaicAssistant.refresh(query);
return;
}
if (chatPath === '/chat' || chatPath.startsWith('/chat/') || /^\/projects\/[0-9a-f-]+\/(?:settings|conversations|tasks|requirements|files)$/i.test(chatPath)) {
@@ -1688,19 +1874,25 @@
// The board page keeps its own title; the Inbox count still follows the bus.
if (shown !== null) { shown = null; unmountEditor(); $('bus-view').innerHTML = ''; document.title = 'Dashboard · Mosaic Console'; if (navigated) $('main').focus(); }
// The held roles (row 95) are read with it. A refusal of either forgets both, as on the bus pages.
const epoch = orgEpoch;
const [inbox, agents, messages, tasks, queue, business, projects] = await Promise.allSettled([
fetchRead('inbox'), fetchRead('agents'), fetchRead('messages'), fetchRead('tasks'), fetchApi('queue'), fetchApi('business'),
fetch('/api/chat/projects', { cache: 'no-store', redirect: 'manual' }).then(async r => { if (r.type === 'opaqueredirect') { signOut(); throw signedOut(); } const body = await r.json(); if (signInRequired(r, body)) { signOutSso(); throw signedOut(); } if (!r.ok || !Array.isArray(body.rows)) throw new ReadError(body?.error, body?.message, r.status); return body; })
]);
const failed = [inbox, agents, messages, tasks].filter(s => s.status === 'rejected').map(s => s.reason);
if (failed.some(err => err.code === 'signed-out')) return;
// #1873 SP1: an answer read for an organization that is no longer open is not kept.
if (epoch !== orgEpoch) return;
if (inbox.status === 'fulfilled') last.set('inbox', inbox.value);
if (agents.status === 'fulfilled') last.set('agents', agents.value);
if (messages.status === 'fulfilled') last.set('messages', messages.value);
const refused = failed.find(refusal);
if (refused) forget();
if (g !== gen) return;
if (inbox.status === 'fulfilled' && !refused) countInbox(inbox.value.rows);
// SP3 (#1873): with organizations the sidebar count is every organization's, from the same
// workspace read as #/inbox, never this one organization's inbox.
if (window.MosaicOrg) window.MosaicWorkspace?.inboxCount?.();
else if (inbox.status === 'fulfilled' && !refused) countInbox(inbox.value.rows);
if (messages.status === 'fulfilled' && !refused) messageCount = messages.value.unread;
const good = result => !refused && result.status === 'fulfilled' ? result.value : null;
const taskRows = good(tasks)?.rows, queueRows = good(queue)?.rows, projectRows = good(projects)?.rows;
@@ -1720,13 +1912,14 @@
return;
}
if (path === '/settings/model-proxy' && shown === route && !navigated) return;
if (path === '/settings/triage' && shown === route && !navigated) return;
if (path === '/settings/organizations' && shown?.split('?')[0] === path && !navigated) return;
if (($('agent-dialog')?.open || document.querySelector('.agent-more[aria-expanded=true]')) && !navigated) { schedule(); return; }
if (navigated || (shown !== route && !samePage)) { unmountEditor(); $('bus-view').innerHTML = loadingView(SOURCES[path.split('/')[1]]); }
let html, state = 'fresh';
const live = reader(true);
try {
if (path !== '/organization' && !wsPage(path) && !(path === '/agents' && window.MosaicOrg) && path !== '/messages' && !['/settings','/settings/appearance','/settings/model-proxy','/settings/organizations'].includes(path)) {
if (path !== '/organization' && !wsPage(path) && !(path === '/agents' && window.MosaicOrg) && path !== '/messages' && !['/settings','/settings/appearance','/settings/model-proxy','/settings/triage','/settings/organizations'].includes(path)) {
try { await live('messages'); }
catch (err) { messageCount = null; if (err.status === 403 || err.code === 'signed-out') throw err; }
}
@@ -1759,8 +1952,11 @@
if (k) restore(k);
// Message on the Board (row 95) lands in the form it opened, addressed to the role.
else if (focusSend && $('send-body')) { $('send-body').focus(); announce(`Message to ${draft.to}`); }
// SP17: a step link on an organization's Workflows card lands in that step's title field.
else if (navigated && window.MosaicWorkflows?.landed?.()) { /* landed() focused the field and said so */ }
else if (navigated && h1) { const target=settingsFocusDisclosure&&path.startsWith('/settings/') ? $('settings-disclosure') : path.startsWith('/settings/') ? ($('settings-page-title')||h1) : h1; settingsFocusDisclosure=false; target.focus(); announce(target.textContent); }
focusSend = false;
window.MosaicWorkspace?.afterPaint?.();
schedule();
}
@@ -1812,7 +2008,7 @@
// Ctrl+K opens it. It lists the views, and the decisions and tasks from the last inbox and
// tasks reads (opening it reads both again, GET only). Enter goes; Esc closes and puts focus
// back where it was. It only navigates.
const VIEWS = [['#/', 'Dashboard'], ['#/projects', 'Projects'], ['#/inbox', 'Inbox'], ['#/messages', 'Assistant'], ['#/tasks', 'Tasks'], ['#/agents', 'Agents'], ['#/queue', 'Queue'], ['#/settings/business', 'Business'], ['#/docs', 'Docs'], ['#/settings', 'Settings'], ['#/settings/display', 'Sidebar display']];
const VIEWS = [['#/', 'Dashboard'], ['#/projects', 'Projects'], ['#/inbox', 'Inbox'], ...(window.MosaicAssistant ? [['#/assistant', 'Assistant'], ['#/messages', 'Messages']] : [['#/messages', 'Assistant']]), ['#/tasks', 'Tasks'], ['#/agents', 'Agents'], ['#/queue', 'Queue'], ['#/settings/business', 'Business'], ['#/docs', 'Docs'], ['#/settings', 'Settings'], ['#/settings/display', 'Sidebar display']];
let pkAll = [], pkShown = [], pkAt = 0, pkBack = null;
function pkItems() {
const decisions = (last.get('inbox')?.rows || []).map(d => ({ href: `#/inbox/${enc(d.id)}`, label: first(d.question), group: `decision ${short(d.id)}` }));
@@ -1834,7 +2030,9 @@
if (d.open) return;
pkBack = document.activeElement; pkAt = 0; $('cmdk-input').value = '';
pkItems(); pkFill(); d.showModal(); $('cmdk-input').focus();
Promise.allSettled(['inbox', 'tasks'].map(async v => last.set(v, await fetchRead(v)))).then(rs => {
const epoch = orgEpoch;
Promise.allSettled(['inbox', 'tasks'].map(async v => { const r = await fetchRead(v); if (epoch === orgEpoch) last.set(v, r); })).then(rs => {
if (epoch !== orgEpoch) return;
if (rs.some(r => r.status === 'rejected' && refusal(r.reason))) { forget(); sections(routeOf().split('?')[0]); }
if (d.open) { pkItems(); pkFill(); }
});
@@ -1874,11 +2072,13 @@
if (out()) { receipt = { kind: 'refused', to: to || 'no role', code: 'sign-in', message: 'signed out; reload the page to sign in again' }; paintSend(); announce('Not sent: ' + receipt.message); return; }
if (!to || !text.trim()) { receipt = { kind: 'refused', to: to || 'no role', code: 'invalid-request', message: to ? 'the message is empty' : 'choose a role first' }; paintSend(); announce('Not sent: ' + receipt.message); return; }
sending = true; receipt = null; paintSend();
const epoch = orgEpoch;
let res = null, body = null;
try {
res = await fetch('/api/bus/message', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ to, body: text }), cache: 'no-store', redirect: 'manual' });
try { body = await res.json(); } catch { body = null; }
} catch { res = null; }
if (epoch !== orgEpoch) { if (res?.type === 'opaqueredirect') signOut(); return; }
// Sent: an id came back. Not sent: a 4xx (refused before the bus wrote), the server's
// sent:false, or a redirect, which only the sign-in proxy gives (an expired session), so the
// request never reached the Console. Anything else, no answer included, may have been sent,
@@ -1909,13 +2109,15 @@
// F3: `settingsSend` lets the owner of an organization Console save Settings on the selected
// organization's bus; messaging a role still follows `send` (canMessage) and `chatSend`.
// A bus restart reads the config again and sends it here as a mosaic-config event.
const applyConfig = c => {
const applyConfig = (c, opts = {}) => {
isTester = c?.tester === true;
canEdit = !isTester && c?.edit === true;
canSend = !isTester && (c?.send === true || c?.settingsSend === true);
canMessage = !isTester && c?.send === true;
chatSend = !isTester && c?.chatSend === true;
orgSetup = !isTester && c?.orgSetup === true;
// #1873 triage-settings: /api/config says proxyAdmin to the instance owner only, the same owner /api/triage/route serves.
triageOwner = !isTester && c?.proxyAdmin === true;
window.MosaicOrgBusStopped = !!window.MosaicOrg && c?.devOwner === true && orgSetup && c?.chatSend === false;
// The header menu offers "New organization" to the owner of a Console with organizations; nobody else can create one.
if (orgSetup && !$('org-new-link')) { const a = document.createElement('a'); a.id = 'org-new-link'; a.href = NEW_ORG; a.setAttribute('role', 'menuitem'); a.textContent = 'New organization'; document.querySelector('#avatar-menu > a[href="#/settings"]')?.after(a); }
@@ -1926,19 +2128,50 @@
banner.setAttribute('role', 'status'); banner.textContent = 'Tester Console. Changes are recorded as tester, never as the human.';
$('main').prepend(banner);
}
if (!canSend && !isTester && !ssoOn) return;
if (opts.quiet || (!canSend && !isTester && !ssoOn)) return;
const path = routeOf().split('?')[0];
if (path.startsWith('/chat')||path.startsWith('/projects')||path.startsWith('/inbox')||path.startsWith('/settings')||path.startsWith('/docs/')||wsPage(path)) render(false); else if (window.MosaicOrg ? path === '/board' : path === '/' || path === '') paintHeld(heldErr);
};
configRead = fetch('/api/config', { cache: 'no-store', redirect: 'manual' }).then(r => { if (r.type === 'opaqueredirect') { signOut(); return null; } return r.json(); }).then(applyConfig).catch(() => {});
configRead = fetch('/api/config', { cache: 'no-store', redirect: 'manual' }).then(r => { if (r.type === 'opaqueredirect') { signOut(); return null; } return r.json(); }).then(c => { applyConfig(c); return c; }).catch(() => null);
// SP14 (#1873): who is signed in, from this same read, for what the page keeps per person
// (assistant.js's kept pane messages). null when the read failed or named nobody.
window.MosaicViewer = configRead.then(c => (typeof c?.viewer === 'string' && c.viewer ? c.viewer : null));
// E1 (P1-5): after Restart bus the organization dashboard draws its bus line now, not at the next poll.
// E2E6 P2-2: a write on the organization page that changes other sections (a pack apply) asks for a
// fresh read of the page; editors in progress are kept by holdLive.
document.addEventListener('mosaic-org-changed', e => { if (window.MosaicOrg && e.detail?.org === window.MosaicOrg.id && routeOf().split('?')[0] === '/organization') render(false); });
// Ruling 2026-11-14: an apply, hire or fire redraws the Agents page in the same response cycle, not at the next poll.
// SP5: the system Agents page shows every organization, so a change in any of them redraws it.
document.addEventListener('mosaic-org-changed', e => { if (!window.MosaicOrg) return; const path = routeOf().split('?')[0]; if ((path === '/agents' && window.MosaicOrg.system()) || (e.detail?.org === window.MosaicOrg.id && ['/organization', '/agents'].includes(path))) render(false); });
// #1873 SP1: another organization opened in place (display.js, before this file's hashchange
// render). Nothing read, drafted or confirmed for the old one carries over; the new one's config
// is read before the next page draws. A write already sent finishes against the old organization,
// and its answer is not drawn on the new one.
document.addEventListener('mosaic-org-switch', () => {
// Writes still in flight keep going to the old organization; their answers are dropped (orgEpoch)
// and every busy flag and receipt starts clean here.
orgEpoch++;
sending = false; receipt = null; replies = [];
hireBusy = false; fireBusy = false; settingsSaving = false; resetReceipt = '';
assistantBusy = false; assistantFormsBusy.clear(); instanceBusyOps = new Set();
routesBusy = false; routesApply = null; harnessBusy = false; harnessLoading = false;
forget(); clearTimeout(timer);
answer = null; heldErr = null; heldHtml = null; readAt = null; shown = null; projectContext = null;
draft.to = ''; draft.body = '';
hireDraft = { op: 'hire', level: 'org' }; hireTemplates = []; hireStatus = ''; hireCode = '';
fireAsk = null; fireReceipt = null;
settingsSnapshot = null; settingsInputs = null; settingsReceipt = ''; settingInvalidKey = null;
assistantDrafts = Object.create(null); nameDrafts = Object.create(null); assistantReceipts = Object.create(null); assistantReceiptKinds = Object.create(null); assistantCardReceipts = Object.create(null);
instanceView = null; instanceDrafts = { add: null, change: null }; instanceReceipt = ''; instanceReceiptOp = null; instanceReceipts = Object.create(null);
routesView = null; routesDraft = null; routesReceipt = ''; routesEditVersion++;
harnessSettings = null; harnessDraft = null; harnessReceipt = '';
// A file draft is keyed by project and path only; the page reload that used to drop it is gone.
docKey = null; docStates.clear(); pkAll = []; pkShown = []; pkAt = 0;
configRead = switchRead = fetch('/api/config', { cache: 'no-store', redirect: 'manual' }).then(r => { if (r.type === 'opaqueredirect') { signOut(); return null; } return r.json(); }).then(c => applyConfig(c, { quiet: true })).catch(() => {});
});
document.addEventListener('mosaic-config', e => { if (e.detail && typeof e.detail === 'object') { applyConfig(e.detail); if (window.MosaicOrg && routeOf().split('?')[0] === '/organization') render(false); } });
// The cross-organization pages ask for a repaint after a filter, sort or selection change,
// and report the inbox count across organizations for the sidebar.
document.addEventListener('mosaic-workspace-render', () => { if (wsPage(routeOf().split('?')[0])) render(false); });
document.addEventListener('mosaic-workspace-render', () => { if (drawerPage(routeOf().split('?')[0])) render(false); });
document.addEventListener('mosaic-workspace-inbox', e => { const d = e.detail; if (d && Number.isFinite(d.open)) { inboxCount = { open: d.open, blocking: Number.isFinite(d.blocking) ? d.blocking : 0 }; sections(routeOf().split('?')[0]); } });
// This context comes from the conversations renderer after its authorized read.
let projectContext = null;
@@ -2015,8 +2248,12 @@
});
nav.addEventListener('click', e => { if (drawerOpen && e.target.closest('a[href^="#/"]')) drawer(false, false); });
window.addEventListener('resize', () => { if (drawerOpen && innerWidth >= 760) drawer(false, false); if (drawerOpen) $('nav-overflow').hidden = nav.scrollHeight <= nav.clientHeight + 1; });
window.addEventListener('hashchange', () => render(true));
window.addEventListener('hashchange', e => render(!agentOnly(e.oldURL, e.newURL)));
$('refresh').addEventListener('click', () => render(false));
$('pause').addEventListener('click', () => setTimeout(schedule)); // after app.js flips aria-pressed
render(false).then(() => { if (!$('bus-view').hidden) { const h1 = $('bus-view').querySelector('h1'); if (h1 && location.hash.startsWith('#/')) h1.focus(); } });
// #1873 triage-followups: the first render ends by focusing the page's heading. A drawer or dialog the
// reader opened before then keeps its focus: the Triage drawer, an agent drawer, the narrow-screen
// menu or any open dialog.
const holdsFocus = () => { const a = document.activeElement; return !!a && (!!a.closest('.ws-drawer:not([hidden]), [data-ws-drawer], dialog[open], [role="dialog"], [role="alertdialog"]') || (drawerOpen && nav.contains(a))); };
render(false).then(() => { if (!$('bus-view').hidden && !holdsFocus()) { const h1 = $('bus-view').querySelector('h1'); if (h1 && location.hash.startsWith('#/')) h1.focus(); } });
})();
+126 -64
View File
@@ -1,6 +1,11 @@
/* Row 129: business chat, isolated from the Board's seat conversations and role composer. */
(() => {
'use strict';
// #1873 SP6: one chat view, more than one instance. The page's own instance (no env) is the chat
// as it always was. An Assistant pane makes its own instance with env.org: its reads and writes
// name that organization in the address, so a send always reaches the pane's own organization,
// whichever organization the page last opened, and its listeners answer only inside its container.
function chatInstance(env = {}) {
const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
// crypto.randomUUID exists only in a secure context; a dev owner Console opened by LAN name
// (http://NAME:PORT/) is not one, so build the same v4 form from getRandomValues there.
@@ -18,6 +23,14 @@
// E2E6 P2-15: a message's `inline code` spans show as code, not as raw backticks. The text is escaped
// first; a pair of single backticks on one line then wraps its already-escaped contents in <code>.
const prose = value => txt(value).replace(/`([^`\n]+)`/g, '<code>$1</code>');
const pane = typeof env.org === 'string', life = new AbortController();
const on = (type, fn, capture = false) => document.addEventListener(type, fn, { capture, signal: life.signal });
// A pane prefixes its element ids so two panes never share one; handlers read them back unprefixed.
const idOf = el => { const id = typeof el?.id === 'string' ? el.id : ''; return pane && id.startsWith(env.prefix) ? 'chat-' + id.slice(env.prefix.length) : id; };
// A pane's ids carry its prefix; byId takes the page's own 'chat-…' name.
const byId = id => document.getElementById(pane && id.startsWith('chat-') ? env.prefix + id.slice(5) : id);
const pid = id => (pane && id.startsWith('chat-') ? env.prefix + id.slice(5) : id);
const mine = target => pane ? !!current?.container.contains(target) : !target?.closest?.('[data-assist-pane]');
const states = new Map(), forms = new Map(), knownRequests = new Map();
const pinnedScrolls = new WeakMap(), settlingPins = new WeakMap();
const pageFlow = log => log.closest('.project-chat') && matchMedia('(max-width: 319px), (max-height: 540px)').matches;
@@ -27,7 +40,7 @@
? (pageTailTarget(log)?.getBoundingClientRect().bottom ?? 0) - innerHeight < 40 || messageEnd && Math.abs((log.lastElementChild?.getBoundingClientRect().bottom ?? 0) - innerHeight) < 40
: log.scrollHeight - log.scrollTop - log.clientHeight < 40;
const pageTailTarget = log => {
const form = log.closest('.project-chat')?.querySelector('#chat-send-form, #chat-room-send-form');
const form = log.closest('.project-chat')?.querySelector(`#${pid('chat-send-form')}, #${pid('chat-room-send-form')}`);
const field = form?.querySelector('textarea');
const usable = current && (!field?.disabled && !current.channelDisabled || state(current.key ?? current.id).pending);
return form && field && usable && form.getClientRects().length ? form : log.lastElementChild;
@@ -69,8 +82,7 @@
const channelMessage = 'The chat channel is disabled for this business. Ask the person who manages it to enable WebUI chat, then refresh.';
function forget() {
generation++; controller?.abort(); states.clear(); forms.clear(); knownRequests.clear(); libraries.clear(); reverts.clear();
window.MosaicRequests?.forget();
window.MosaicProjectArchive?.forget();
if (!pane) { window.MosaicRequests?.forget(); window.MosaicProjectArchive?.forget(); }
if (current) current.container.replaceChildren();
current = null;
}
@@ -78,11 +90,21 @@
signedOut = true; forget();
document.dispatchEvent(new Event('mosaic-signed-out'));
}
// SP11: whether the thread's agent runs no process, from the bus instances read the Agents page uses.
// true: paused or stopped; false: running; null: the read failed or does not list the agent.
async function agentIdle(instance, signal) {
try {
const res = await fetch(pane ? `/api/orgs/${encodeURIComponent(env.org)}/bus/instances` : '/api/bus/instances', { cache: 'no-store', redirect: 'manual', signal });
if (!res.ok || res.type === 'opaqueredirect') return null;
const item = (await res.json())?.rows?.[0]?.instances?.[instance];
return item && typeof item === 'object' && Array.isArray(item.running) ? item.running.length === 0 : null;
} catch (err) { if (err.name === 'AbortError') throw err; return null; }
}
async function request(path, value, signal) {
if (out()) throw new ChatError('signed-out');
let res;
try {
res = await fetch('/api/chat/' + path, {
res = await fetch((pane ? `/api/orgs/${encodeURIComponent(env.org)}/chat/` : '/api/chat/') + path, {
cache: 'no-store', redirect: 'manual', signal,
...(value === undefined ? {} : { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(value) }),
});
@@ -104,12 +126,14 @@
}
// In organization mode #/projects is the cross-organization page, so the organization's own
// project list lives at #/chat. That list keeps the project surface and its #/projects links.
const legacyRoute = () => { const r = window.MosaicOrg?.route() ?? location.hash.slice(1); return r.startsWith('/chat') && !(window.MosaicOrg && r.split('?')[0] === '/chat'); };
const projectPath = id => legacyRoute() ? `#/chat/projects/${id}` : `#/projects/${id}`;
const threadPath = id => legacyRoute() ? `#/chat/threads/${id}` : `#/projects/threads/${id}`;
const roomPath = id => legacyRoute() ? `#/chat/rooms/${id}` : `#/projects/rooms/${id}`;
const orgBase = pane ? '#/orgs/' + encodeURIComponent(env.org) : '#';
const legacyRoute = () => { if (pane) return false; const r = window.MosaicOrg?.route() ?? location.hash.slice(1); return r.startsWith('/chat') && !(window.MosaicOrg && r.split('?')[0] === '/chat'); };
const projectPath = id => legacyRoute() ? `#/chat/projects/${id}` : `${orgBase}/projects/${id}`;
const threadPath = id => legacyRoute() ? `#/chat/threads/${id}` : `${orgBase}/projects/threads/${id}`;
const roomPath = id => legacyRoute() ? `#/chat/rooms/${id}` : `${orgBase}/projects/rooms/${id}`;
const link = (type, id, label) => UUID.test(id) ? `<a href="${type === 'projects' ? projectPath(id) : threadPath(id)}">${txt(label)}</a>` : txt(label);
const heading = text => `<h1 tabindex="-1">${txt(text)}</h1>`;
// A pane's title is its own header; the page keeps its one h1.
const heading = text => pane ? `<p class="chat-pane-state"><strong>${txt(text)}</strong></p>` : `<h1 tabindex="-1">${txt(text)}</h1>`;
const selectedInactive = () => { const s = current?.sessions?.find(r => r.id === current.session); return !!s?.state && s.state !== 'active'; };
const disabledSession = pending => disabled(pending || selectedInactive());
const disabled = pending => !current.canSend || current.orgArchived || out() || pending ? ' disabled' : '';
@@ -199,7 +223,8 @@
return `<div class="chat-library"><p role="status">${parts.join(' · ')}</p>${list}</div>`;
}
async function loadLibrary(project, g, signal) {
if (project === null) return;
// The library routes read the page's organization, not a pane's: a pane shows no library line.
if (project === null || pane) return;
let entry;
try {
const res = await fetch('/api/library/status?project=' + encodeURIComponent(project), { cache: 'no-store', redirect: 'manual', signal });
@@ -241,6 +266,8 @@
const REQUEST_ROWS = 3;
// The request panel, Files and summary each read independently. Share only confirmed
// request-not-found responses while a thread is open, without changing other fetch paths.
// Panes mount no request panels, so only the page's instance wraps fetch.
if (!pane) {
const fetchPage = window.fetch.bind(window);
window.fetch = async (url, init) => {
const path = typeof url === 'string' && /^\/api\/requests\/([A-Za-z0-9][A-Za-z0-9._-]{0,159})(?:\/workspace)?$/.exec(url);
@@ -260,11 +287,12 @@
}
return response;
};
}
// A request read elsewhere on this page (any requests.js panel) proves the id now exists, so
// every open thread forgets that miss and the next refresh reads it again. The id's own
// generation also advances, so a 404 still in flight from before this observation cannot
// record the miss after it. Only that id moves; other ids' slow misses still settle.
document.addEventListener('mosaic-request-state', event => {
on('mosaic-request-state', event => {
const id = event.detail?.state?.request;
if (typeof id !== 'string' || out()) return;
for (const s of states.values()) {
@@ -274,7 +302,7 @@
});
function requestRows(rows) {
const ids = new Set();
if (!window.MosaicRequests || !roomOwner()) return ids;
if (pane || !window.MosaicRequests || !roomOwner()) return ids;
for (let i = rows.length - 1; i >= 0 && ids.size < REQUEST_ROWS; i--) {
const m = rows[i];
if (m.from_role === 'human' && typeof m.request === 'string' && REQUEST_ID.test(m.request)) ids.add(m.id);
@@ -286,7 +314,7 @@
const withRequest = requestRows(s.rows);
const receipt = s.receipt;
const project = current.projects.find(p => p.id === t.project);
const redesigned = project && roomOwner() && window.MosaicProjects && (!legacyRoute() || current.path?.startsWith('/projects'));
const redesigned = !pane && project && roomOwner() && window.MosaicProjects && (!legacyRoute() || current.path?.startsWith('/projects'));
// Keep each request tied to its originating message while placing its card after the first reply.
const mountsAfter = new Map();
if (redesigned) s.rows.forEach((m, i) => {
@@ -297,9 +325,13 @@
});
const mount = m => `<div class="request-mount" data-request="${esc(m.request)}" data-origin-message="${esc(m.id)}"></div>`;
const messages = s.rows.map((m, i) => `<li class="${m.from_role === 'human' ? 'chat-message-human' : 'chat-message-agent'}" data-message="${esc(m.id)}"><div class="chat-message-meta"><span class="chat-avatar" aria-hidden="true">${txt(String(m.from_role || '?').slice(0, 1).toUpperCase())}</span><strong>${txt(m.from_role === 'human' ? 'You' : m.from_role)}</strong> ${stamp(m.at)}</div>${messageBody(m)}${!redesigned && withRequest.has(m.id) ? mount(m) : ''}</li>${redesigned ? (mountsAfter.get(i) || []).map(origin => `<li class="project-request-item">${mount(origin)}</li>`).join('') : ''}`).join('');
const frame = redesigned ? window.MosaicProjects.header(project, 'conversations', current.threads, t.name, true) : heading(t.name);
const details = redesigned ? `<dialog class="chat-details project-dialog" id="project-conversation-dialog" aria-labelledby="project-conversation-title"><h2 id="project-conversation-title" tabindex="-1">Conversation details</h2><button class="btn" type="button" data-dialog-close>Close</button>${sessionControls(t)}${sharing(t)}<p>Reading never wakes the assistant. An accepted message is not an answer.</p>${threadWrites() ? `<button class="btn" type="button" id="chat-resume"${disabledSession(s.pending || current.channelDisabled)}>Resume assistant</button>` : ''}</dialog>` : `<details class="chat-details"><summary id="chat-details-toggle">Conversation details</summary>${sessionControls(t)}${sharing(t)}</details><p class="muted">Reading never wakes the assistant. An accepted message is not an answer.</p>${threadWrites() ? `<button class="btn" type="button" id="chat-resume"${disabledSession(s.pending || current.channelDisabled)}>Resume assistant</button>` : ''}`;
return `<section class="chat-conversation${redesigned ? ' project-chat' : ''}" data-project="${esc(t.project)}" data-thread="${esc(t.id)}" data-session="${esc(current.session)}"><p>${link('projects', t.project, current.projects.find(p => p.id === t.project)?.name ?? 'Project')} / ${txt(t.instance)}</p>${frame}${libraryLine(libraryOf(current, t))}${details}${redesigned ? '<p class="small muted" data-conversation-request-status></p>' : ''}<ol class="chat-log" tabindex="0" aria-label="Thread conversation">${messages || (current.readFailed ? '<li class="muted">Messages unavailable.</li>' : '<li class="muted">No messages yet.</li>')}</ol><div class="chat-paging">${current.readFailed ? '<button type="button" class="btn" data-chat-retry>Read again</button>' : s.more ? '<p>Showing earlier history. Read forward to reach the current conversation.</p><button class="btn" type="button" id="chat-next">Read next messages</button>' : '<p class="muted">Caught up to the last read.</p>'}<button class="btn" type="button" id="chat-new"${s.follow ? ' hidden' : ''}>New messages — go to end</button></div>${threadWrites() ? `<form id="chat-send-form"><label for="chat-body">Message ${txt(t.instance)}</label><textarea id="chat-body" rows="4" placeholder="${redesigned ? `Message ${esc(t.instance)}` : 'Write a message…'}"${disabledSession(s.pending)}>${esc(s.draft)}</textarea><p class="chat-audience">To: ${redesigned ? `<span class="room-chip" aria-label="Recipient ${esc(t.instance)}">${txt(t.instance)}</span>` : `${txt(t.instance)} · Private conversation`}</p>${redesigned ? '<p class="project-composer-hint">Enter adds a new line.</p>' : ''}<button class="btn primary" type="submit"${disabledSession(s.pending || current.channelDisabled)}>Send</button></form>` : ''}<p id="chat-receipt" role="status">${txt(receipt)}</p>${redesigned ? '' : '<section class="chat-files"><h2>Files</h2><div data-chat-files>Files unavailable.</div></section><div data-chat-summary></div>'}</section>`;
const frame = pane ? '' : redesigned ? window.MosaicProjects.header(project, 'conversations', current.threads, t.name, true) : heading(t.name);
// A pane leaves out the details: sessions and sharing are unavailable on an organization Console.
// SP11: Resume shows unless the instances read says the agent is running.
const resumable = threadWrites() && current.agentIdle !== false;
const resume = resumable ? `<button class="btn${pane ? ' pane-resume' : ''}" type="button" id="chat-resume"${disabledSession(s.pending || current.channelDisabled)}>Resume assistant</button>` : '';
const details = pane ? `<p class="muted small">Reading never wakes the assistant. An accepted message is not an answer.</p>` : redesigned ? `<dialog class="chat-details project-dialog" id="project-conversation-dialog" aria-labelledby="project-conversation-title"><h2 id="project-conversation-title" tabindex="-1">Conversation details</h2><button class="btn" type="button" data-dialog-close>Close</button>${sessionControls(t)}${sharing(t)}<p>Reading never wakes the assistant. An accepted message is not an answer.</p>${resumable ? `<button class="btn" type="button" id="chat-resume"${disabledSession(s.pending || current.channelDisabled)}>Resume assistant</button>` : ''}</dialog>` : `<details class="chat-details"><summary id="chat-details-toggle">Conversation details</summary>${sessionControls(t)}${sharing(t)}</details><p class="muted">Reading never wakes the assistant. An accepted message is not an answer.</p>${resumable ? `<button class="btn" type="button" id="chat-resume"${disabledSession(s.pending || current.channelDisabled)}>Resume assistant</button>` : ''}`;
return `<section class="chat-conversation${redesigned ? ' project-chat' : ''}" data-project="${esc(t.project)}" data-thread="${esc(t.id)}" data-session="${esc(current.session)}">${pane ? '' : `<p>${link('projects', t.project, current.projects.find(p => p.id === t.project)?.name ?? 'Project')} / ${txt(t.instance)}</p>`}${frame}${libraryLine(libraryOf(current, t))}${details}${redesigned ? '<p class="small muted" data-conversation-request-status></p>' : ''}<ol class="chat-log" tabindex="0" aria-label="Thread conversation">${messages || (current.readFailed ? '<li class="muted">Messages unavailable.</li>' : '<li class="muted">No messages yet.</li>')}</ol><div class="chat-paging">${current.readFailed ? '<button type="button" class="btn" data-chat-retry>Read again</button>' : s.more ? '<p>Showing earlier history. Read forward to reach the current conversation.</p><button class="btn" type="button" id="chat-next">Read next messages</button>' : '<p class="muted">Caught up to the last read.</p>'}<button class="btn" type="button" id="chat-new"${s.follow ? ' hidden' : ''}>New messages — go to end</button></div>${threadWrites() ? `<form id="chat-send-form"><label for="chat-body">Message ${txt(t.instance)}</label><textarea id="chat-body" rows="4" placeholder="${redesigned ? `Message ${esc(t.instance)}` : 'Write a message…'}"${disabledSession(s.pending)}>${esc(s.draft)}</textarea><p class="chat-audience">To: ${redesigned ? `<span class="room-chip" aria-label="Recipient ${esc(t.instance)}">${txt(t.instance)}</span>` : `${txt(t.instance)} · Private conversation`}</p>${redesigned ? '<p class="project-composer-hint">Enter adds a new line.</p>' : ''}<button class="btn primary" type="submit"${disabledSession(s.pending || current.channelDisabled)}>Send</button></form>` : ''}<p id="chat-receipt" role="status">${txt(receipt)}</p>${pane ? resume : ''}${redesigned || pane ? '' : '<section class="chat-files"><h2>Files</h2><div data-chat-files>Files unavailable.</div></section><div data-chat-summary></div>'}</section>`;
}
// C2-10c: rooms reuse the same state, renderer and generation fences as threads.
const ROOM_LINES = Object.freeze({
@@ -475,19 +507,20 @@
if (err.code === 'channel-disabled' && current?.key === c.key) current.channelDisabled = true;
} finally { s.pending = false; if (current?.key === c.key && !out()) paint(); }
}
document.addEventListener('keydown', event => {
if (current?.kind !== 'room' || event.target.id !== 'chat-room-body' || !current.completion?.items.length) return;
on('keydown', event => {
if (!mine(event.target)) return;
if (current?.kind !== 'room' || idOf(event.target) !== 'chat-room-body' || !current.completion?.items.length) return;
const c = current.completion;
if (['ArrowDown', 'ArrowUp'].includes(event.key)) { event.preventDefault(); c.index = (c.index + (event.key === 'ArrowDown' ? 1 : c.items.length - 1)) % c.items.length; drawRoomCompletion(); }
if (['Enter', 'Tab'].includes(event.key)) { event.preventDefault(); completeRoom(c.items[c.index].instance); }
if (event.key === 'Escape') { event.preventDefault(); current.completion = null; drawRoomCompletion(); }
});
document.addEventListener('mousedown', event => { if (event.target.closest?.('[data-room-complete]')) event.preventDefault(); });
on('mousedown', event => { if (event.target.closest?.('[data-room-complete]')) event.preventDefault(); });
function capture() {
if (!current) return null;
const active = document.activeElement, log = current.container.querySelector('.chat-log');
const field = active?.id?.startsWith('chat-') ? { id: active.id, start: active.selectionStart, end: active.selectionEnd } : null;
const field = idOf(active).startsWith('chat-') && current.container.contains(active) ? { id: active.id, start: active.selectionStart, end: active.selectionEnd } : null;
const dialog = current.container.querySelector('dialog.project-dialog[open]');
const dialogValues = dialog ? [...dialog.querySelectorAll('input[id],select[id],textarea[id]')].map(e=>({id:e.id,value:e.value,checked:e.checked})) : [];
const dialogFocus = dialog?.contains(active) ? { id:active.id, index:[...dialog.querySelectorAll('button,a,input,select,textarea,[tabindex]')].indexOf(active), value:'value' in active ? active.value : null, start:active.selectionStart, end:active.selectionEnd } : null;
@@ -512,7 +545,7 @@
// Refreshes often read exactly the same view. Remember the generated presentation,
// not the mutable DOM (which also contains independently mounted request controls).
function refreshProjectData(c, redesigned, restore) {
if (c.user || c.tester || !window.MosaicProjects) return;
if (pane || c.user || c.tester || !window.MosaicProjects) return;
const project = c.projects.find(p => p.id === c.id);
const projectContent = c.container.querySelector('[data-project-content]');
if (redesigned && (c.kind === 'project' || c.kind === 'thread' || c.kind === 'room')) {
@@ -526,6 +559,7 @@
// visible view is unchanged: a request's phase moves without a new message. A quiet reread
// keeps the present content until a changed result arrives.
function refreshRequestData(c, quiet) {
if (pane) return;
window.MosaicRequests?.mount?.(c.container, { archiveUnknown: !!c.archiveUnknown, projectArchived: !!c.projectArchived });
const t = c.kind === 'thread' ? c.thread : null;
const repo = c.kind === 'project' ? c.projects.find(p => p.id === c.id)?.repo : libraryOf(c, t);
@@ -562,7 +596,7 @@
});
for (let i = 0; i < desired.length; i++) if (liveLog.children[i] !== desired[i]) liveLog.insertBefore(desired[i], liveLog.children[i] || null);
while (liveLog.children.length > desired.length) liveLog.lastElementChild.remove();
window.MosaicRequests?.mount?.(c.container, { archiveUnknown: !!c.archiveUnknown, projectArchived: !!c.projectArchived });
if (!pane) window.MosaicRequests?.mount?.(c.container, { archiveUnknown: !!c.archiveUnknown, projectArchived: !!c.projectArchived });
const s = state(c.key ?? c.id);
if (s.tailRequested || s.follow && ((keep?.tail ?? true) || keep?.settlingPin)) pinTranscript(liveLog);
else if (keep?.top !== undefined) { if (pageFlow(liveLog)) window.scrollTo(0, keep.top); else liveLog.scrollTop = keep.top; }
@@ -604,8 +638,8 @@
function paint(navigated = false, read = false) {
if (!current || out()) return;
const keep = capture(), c = current;
const redesigned = (!legacyRoute() || c.path?.startsWith('/projects')) && !!window.MosaicProjects && !c.user && !c.tester;
let html = '<div class="chat-area"><p><a href="#/projects">Projects</a></p>';
const redesigned = !pane && (!legacyRoute() || c.path?.startsWith('/projects')) && !!window.MosaicProjects && !c.user && !c.tester;
let html = pane ? '<div class="chat-area">' : '<div class="chat-area"><p><a href="#/projects">Projects</a></p>';
if (c.orgArchived) html += `<p role="status">${c.orgArchived === 'room-not-open' ? 'This room is not open.' : 'This organization is archived.'} Sending is unavailable; your draft is kept.</p>`;
if (c.error && !(c.kind === 'room' && c.error === ROOM_LINES['room-not-open'] && redesigned)) html += `<p class="chat-error banner err" role="alert">${txt(c.error)}</p>`;
if (c.archiveUnknown && !c.loading) html += '<p role="status" data-archive-notice>Archive status unavailable. Some changes are unavailable; sending may be refused; refresh to check.</p>';
@@ -635,8 +669,10 @@
} else {
html += heading('Projects') + '<p>Projects and their conversations.</p><div class="chat-projects">' + c.projects.map(p => `<section class="panel"><h2>${link('projects', p.id, p.name)}</h2>${p.repo ? `<p class="muted">Repository: ${txt(p.repo)}</p>` : ''}${threads(c.threads.filter(t => t.project === p.id && !t.shared))}</section>`).join('') + (c.projects.length ? '' : c.readFailed ? '<p>Projects unavailable.</p>' : '<p>No projects yet.</p>') + '</div><h2>Shared with me</h2>' + threads(c.threads.filter(t => t.shared)) + creation('project', 'projects');
}
if (!c.canSend) html += window.MosaicOrgBusStopped ? '<p class="muted">The bus is stopped. Use Start the bus on Settings → Organizations to send messages.</p>' : '<p class="muted">Creating and sending require signed-in send mode. This Console only reads.</p>';
if (!c.canSend && pane) html += '<p class="muted">Sending is unavailable in this organization. This thread only reads.</p>';
else if (!c.canSend) html += window.MosaicOrgBusStopped ? '<p class="muted">The bus is stopped. Use Start the bus on Settings → Organizations to send messages.</p>' : '<p class="muted">Creating and sending require signed-in send mode. This Console only reads.</p>';
html += '</div>';
if (pane) html = html.replace(/\b(id|for|aria-controls|aria-describedby|aria-labelledby)="chat-/g, `$1="${env.prefix}`);
// Drafts already live in the focused textarea; their changing text is not a
// reason for a background read to replace the control.
const fingerprint = visualKey(html);
@@ -690,13 +726,13 @@
// which names the project as the organization file does: the chat project's repo key.
if (remote && roomOwner() && window.MosaicOrg && typeof window.MosaicProjectRepo?.mount === 'function') window.MosaicProjectRepo.mount({ container: remote, project: project?.repo ?? null, archived: !!c.projectArchived });
else if (remote && roomOwner() && typeof window.MosaicProjectRemote?.mount === 'function') { remote.replaceChildren(); window.MosaicProjectRemote.mount({ container: remote, projectId: c.id, repositoryKey: project?.repo ?? null, projectArchived: !!c.projectArchived, preserve: true }); }
if (!window.MosaicOrg && (!redesigned || c.kind !== 'project' || c.settings || c.projectArchived)) window.MosaicProjectArchive?.mount(c.container, c);
if (!pane && !window.MosaicOrg && (!redesigned || c.kind !== 'project' || c.settings || c.projectArchived)) window.MosaicProjectArchive?.mount(c.container, c);
if (redesigned && c.kind === 'project' && c.projectArchived && !c.settings) {
const controls = c.container.querySelector('.project-archive-control');
if (controls) c.container.querySelector('.project-tabs')?.insertAdjacentElement('afterend', controls);
}
refreshProjectData(c, redesigned, !navigated ? keep : null);
document.title = `${c.container.querySelector('h1')?.textContent ?? 'Chat'} · Mosaic Console`;
if (!pane) document.title = `${c.container.querySelector('h1')?.textContent ?? 'Chat'} · Mosaic Console`;
if (!navigated && keep?.toggles) [...c.container.querySelectorAll('.project-new-conversation,.project-create')].forEach((e,i)=>{e.open=!!keep.toggles[i];});
const details = c.container.querySelector('.chat-details');
if (details && keep?.detailsOpen && details.tagName === 'DETAILS') details.open = true;
@@ -736,7 +772,7 @@
f.focus({ preventScroll: true });
if (keep.field.start != null && typeof f.setSelectionRange === 'function') f.setSelectionRange(keep.field.start, keep.field.end);
}
} else if (navigated) c.container.querySelector('h1')?.focus({ preventScroll: true });
} else if (navigated && !pane) c.container.querySelector('h1')?.focus({ preventScroll: true });
updateRoomCompletion();
}
function readError(err) {
@@ -765,7 +801,7 @@
paint(); return;
}
const old = current;
current = { container, kind, id, orgArchived: old?.orgArchived ?? false, loading: true, archiveUnknown: kind === 'thread' && !user && !tester, settings: !!settings, section, path: originalPath, canSend, user, tester, chatGrants: [], thread: old && old.id === id ? old.thread : null, shared: old && old.id === id ? old.shared : false, projects: old?.projects ?? [], threads: old?.threads ?? [], repos: old?.repos ?? [], instances: old?.instances ?? [], instanceError: kind === 'project' ? 'Reading thread instances…' : '', error: '', readFailed: false, channelDisabled: old?.channelDisabled ?? false, refused: false, legacyDefault: old && old.id === id ? old.legacyDefault : false, sessions: old && old.id === id ? old.sessions ?? [] : [], session: match[3] ?? (old && old.id === id ? old.session : null), key: match[3] ? id + '/' + match[3] : old && old.id === id ? old.key : id };
current = { container, kind, id, orgArchived: old?.orgArchived ?? false, loading: true, archiveUnknown: kind === 'thread' && !user && !tester, settings: !!settings, section, path: originalPath, canSend, user, tester, chatGrants: [], thread: old && old.id === id ? old.thread : null, shared: old && old.id === id ? old.shared : false, projects: old?.projects ?? [], threads: old?.threads ?? [], repos: old?.repos ?? [], instances: old?.instances ?? [], instanceError: kind === 'project' ? 'Reading thread instances…' : '', error: '', readFailed: false, channelDisabled: old?.channelDisabled ?? false, refused: false, legacyDefault: old && old.id === id ? old.legacyDefault : false, sessions: old && old.id === id ? old.sessions ?? [] : [], session: match[3] ?? (old && old.id === id ? old.session : null), key: match[3] ? id + '/' + match[3] : old && old.id === id ? old.key : id, agentIdle: old && old.id === id ? old.agentIdle : null };
current.projectArchived = current.projects.some(p => p.id === (kind === 'project' ? id : current.thread?.project) && p.archived);
if (kind === 'thread' && old?.kind === 'thread' && old.id === id && !navigated && old.archiveUnknown === false && old.projects.some(p => p.id === old.thread?.project)) current.archiveUnknown = false;
if (current.projectArchived) current.archiveUnknown = false;
@@ -773,8 +809,8 @@
// server paths lack archive guards, and the request panel's writes.
const withdraw = () => {
lastPaint = null;
for (const el of container.querySelectorAll('#chat-session-form input, #chat-session-form button, #chat-share-form input, #chat-share-form button, [data-unshare], #chat-cancel, [data-revert]')) el.disabled = true;
window.MosaicRequests?.mount?.(container, { archiveUnknown: !!current.archiveUnknown, projectArchived: !!current.projectArchived });
for (const el of container.querySelectorAll(['chat-session-form input', 'chat-session-form button', 'chat-share-form input', 'chat-share-form button', 'chat-cancel'].map(x => '#' + pid(x)).concat('[data-unshare]', '[data-revert]').join(', '))) el.disabled = true;
if (!pane) window.MosaicRequests?.mount?.(container, { archiveUnknown: !!current.archiveUnknown, projectArchived: !!current.projectArchived });
if (!current.archiveUnknown) return;
if (container.querySelector('[data-archive-notice]')) return;
const notice = document.createElement('p');
@@ -815,7 +851,8 @@
current.thread = current.threads.find(t => t.id === id);
current.shared = current.thread?.shared === true;
const projectId = kind === 'project' ? id : current.thread?.project;
if (projectId && !current.projects.some(p => p.id === projectId) && !user && !tester) {
// A pane leaves an unlisted project's archive state unknown: the archive lookup reads the page's organization.
if (projectId && !current.projects.some(p => p.id === projectId) && !user && !tester && !pane) {
try {
if (typeof window.MosaicProjectArchive?.resolve !== 'function') throw Error('archive-unavailable');
const resolved = await window.MosaicProjectArchive.resolve(projectId, signal);
@@ -830,7 +867,7 @@
current.archiveUnknown = true;
}
}
else if (projectId) current.archiveUnknown = false;
else if (projectId && (!pane || current.projects.some(p => p.id === projectId))) current.archiveUnknown = false;
current.projectArchived = current.projects.some(p => p.id === projectId && p.archived);
// A same-thread refresh kept the controls of the last resolved (live) state. If this
// lookup now finds the project archived or unknown, withdraw them before the slower
@@ -848,6 +885,10 @@
if (g !== generation || out()) return;
current.shares = shares.rows;
}
if (kind === 'thread' && current.thread && threadWrites()) {
current.agentIdle = await agentIdle(current.thread.instance, signal);
if (g !== generation || out()) return;
}
let s = null, page = null, after = null;
if (kind === 'thread' && catalog === null) {
current.legacyDefault = true; current.sessions = []; current.session = null;
@@ -958,7 +999,7 @@
for (const row of state(current.key).rows) if (row.from_role === 'human' && typeof row.request === 'string' && REQUEST_ID.test(row.request)) ids.add(row.request);
knownRequests.set(projectId, { repo: project.repo, ids });
}
if (project) document.dispatchEvent(new CustomEvent('mosaic-project-context', { detail: { projectId, repositoryKey: project.repo ?? null, thread: kind === 'thread' ? id : null, session: kind === 'thread' ? current.session : null } }));
if (project && !pane) document.dispatchEvent(new CustomEvent('mosaic-project-context', { detail: { projectId, repositoryKey: project.repo ?? null, thread: kind === 'thread' ? id : null, session: kind === 'thread' ? current.session : null } }));
}
paint(navigated, true);
const t = kind === 'thread' ? current.threads.find(t => t.id === id) : null;
@@ -988,17 +1029,17 @@
}
}
function refresh(next = false) {
if (current) return render({ ...current, path: (window.MosaicOrg?.route() ?? location.hash.slice(1)).split('?')[0], next });
if (current) return render({ ...current, path: pane ? current.path : (window.MosaicOrg?.route() ?? location.hash.slice(1)).split('?')[0], next });
}
function leave(path) {
if (!path.startsWith('/chat') && !path.startsWith('/projects')) { generation++; controller?.abort(); current = null; }
}
document.addEventListener('input', event => {
if (!current || out()) return;
if (event.target.id === 'chat-room-body') { state(current.key).draft = event.target.value; updateRoomCompletion(); return; }
if (event.target.id === 'chat-operation') { const f = form('clear:' + current.key); if (f.pending) return; f.op = event.target.value; f.record = null; const button = document.getElementById('chat-cancel'); if (button) button.disabled = !current.canSend || current.archiveUnknown || current.projectArchived || f.pending || !f.op; }
if (event.target.id === 'chat-share-target') form('share:' + current.id).to = event.target.value;
if (event.target.id === 'chat-body') state(current.key ?? current.id).draft = event.target.value;
on('input', event => {
if (!current || out() || !mine(event.target)) return;
if (idOf(event.target) === 'chat-room-body') { state(current.key).draft = event.target.value; updateRoomCompletion(); return; }
if (idOf(event.target) === 'chat-operation') { const f = form('clear:' + current.key); if (f.pending) return; f.op = event.target.value; f.record = null; const button = byId('chat-cancel'); if (button) button.disabled = !current.canSend || current.archiveUnknown || current.projectArchived || f.pending || !f.op; }
if (idOf(event.target) === 'chat-share-target') form('share:' + current.id).to = event.target.value;
if (idOf(event.target) === 'chat-body') state(current.key ?? current.id).draft = event.target.value;
const f = event.target.closest('.chat-create');
if (f && event.target.dataset.chatField) {
const draft = form(f.dataset.key), field = event.target.dataset.chatField;
@@ -1010,7 +1051,7 @@
// User input cancels a pending page pin, including scrollbar dragging.
// Tab counts from any target: it moves focus and can scroll the document.
const readerInput = event => {
if (!['thread', 'room'].includes(current?.kind)) return;
if (!['thread', 'room'].includes(current?.kind) || !mine(event.target)) return;
if (event.type === 'keydown' && event.key !== 'Tab' && (!['ArrowUp', 'ArrowDown', 'PageUp', 'PageDown', 'Home', 'End', ' '].includes(event.key) || event.target.closest?.('input, textarea, select, button, a, [contenteditable=true]'))) return;
if (event.type === 'pointerdown' && event.target !== document.documentElement && event.target !== document.body && !event.target.matches?.('.chat-log')) return;
const log = current.container.querySelector('.chat-log');
@@ -1024,8 +1065,8 @@
}
else if (event.key === 'Tab' || event.target === log || log.contains(event.target)) { pinnedScrolls.delete(log); settlingPins.delete(log); }
};
for (const type of ['wheel', 'touchstart', 'pointerdown', 'keydown']) document.addEventListener(type, readerInput, true);
document.addEventListener('scroll', event => {
for (const type of ['wheel', 'touchstart', 'pointerdown', 'keydown']) on(type, readerInput, true);
on('scroll', event => {
if (!['thread', 'room'].includes(current?.kind)) return;
const log = current.container.querySelector('.chat-log');
if (!log) return;
@@ -1110,25 +1151,25 @@
if (!out() && current && (isThread ? (current.key ?? current.id) === key : (action === 'createSession' ? current.id === targetThread : key === 'projects' ? current.kind === 'list' : current.id === key))) paint();
}
}
document.addEventListener('submit', event => {
if (!current || !event.target.id.startsWith('chat-')) return;
on('submit', event => {
if (!current || !mine(event.target) || !idOf(event.target).startsWith('chat-')) return;
event.preventDefault();
if (event.target.id === 'chat-room-send-form') {
if (idOf(event.target) === 'chat-room-send-form') {
void sendRoom();
} else if (event.target.id === 'chat-share-form') {
} else if (idOf(event.target) === 'chat-share-form') {
void changeShare('share', form('share:' + current.id).to ?? '');
} else if (event.target.id === 'chat-send-form') {
} else if (idOf(event.target) === 'chat-send-form') {
const id = current.id, session = current.session, key = current.key;
void write('send', key, { body: state(key).draft, ...(session ? { session } : {}) }, `threads/${id}/messages`);
} else if (event.target.id === 'chat-session-form') {
} else if (idOf(event.target) === 'chat-session-form') {
const key = 'session:' + current.id, f = form(key);
// Keep an ambiguous create's key and payload; editing requires a deliberate new attempt.
f.op ??= opId();
f.payload ??= { name: f.name, op: f.op };
void write('createSession', key, f.payload, `threads/${current.id}/sessions`);
} else if (event.target.id === 'chat-operation-form') {
} else if (idOf(event.target) === 'chat-operation-form') {
const clear = form('clear:' + current.key);
clear.op = document.getElementById('chat-operation').value;
clear.op = byId('chat-operation').value;
void checkClear(current.id, current.key, clear);
} else if (event.target.classList.contains('chat-create')) {
const key = event.target.dataset.key, f = form(key), project = key === 'projects';
@@ -1137,9 +1178,9 @@
void write(project ? 'createProject' : 'createThread', key, value, project ? 'projects' : 'threads');
}
});
document.addEventListener('click', event => {
if (!current || out()) return;
if (event.target.id === 'chat-room-open' || event.target.closest?.('[data-room-open-inline]')) void openRoom();
on('click', event => {
if (!current || out() || !mine(event.target)) return;
if (idOf(event.target) === 'chat-room-open' || event.target.closest?.('[data-room-open-inline]')) void openRoom();
const projectRoomOpen=event.target.closest?.('[data-project-room-open]'); if(projectRoomOpen && UUID.test(projectRoomOpen.dataset.projectRoomOpen)) void openRoom(projectRoomOpen.dataset.projectRoomOpen);
const chip = event.target.closest?.('[data-room-chip]');
if (chip) { const name = chip.dataset.roomChip; document.querySelector(`[data-room-member="${CSS.escape(name)}"]`)?.click(); document.querySelector(`[data-room-chip="${CSS.escape(name)}"]`)?.focus(); }
@@ -1154,16 +1195,17 @@
const option = event.target.closest?.('[data-room-complete]');
if (option) completeRoom(option.dataset.roomComplete);
if (event.target.dataset.unshare) void changeShare('unshare', event.target.dataset.unshare);
if (event.target.id === 'chat-resume') void write('open', current.key, current.session ? { session: current.session } : {}, `threads/${current.id}/open`);
if (event.target.id === 'chat-cancel') void cancelClear();
if (event.target.id === 'chat-clear') void clearContext();
if (event.target.id === 'chat-next') void refresh(true);
if (idOf(event.target) === 'chat-resume') void write('open', current.key, current.session ? { session: current.session } : {}, `threads/${current.id}/open`);
if (idOf(event.target) === 'chat-cancel') void cancelClear();
if (idOf(event.target) === 'chat-clear') void clearContext();
if (idOf(event.target) === 'chat-next') void refresh(true);
if (event.target.closest?.('[data-chat-retry]')) void refresh();
const revertButton = event.target.closest?.('[data-revert]');
if (revertButton) void revert(revertButton.dataset.revert);
if (event.target.id === 'chat-new') { state(current.key ?? current.id).tailRequested = true; state(current.key ?? current.id).follow = true; paint(); }
if (idOf(event.target) === 'chat-new') { state(current.key ?? current.id).tailRequested = true; state(current.key ?? current.id).follow = true; paint(); }
});
document.addEventListener('change', event => {
on('change', event => {
if (!mine(event.target)) return;
if (event.target.matches?.('[data-room-member]') && current?.kind === 'room') {
const field = document.getElementById('chat-room-body'), s = state(current.key);
const parsed = roomAddress(field.value);
@@ -1175,7 +1217,7 @@
s.draft = chosen.map(name => '@' + name).join(' ') + (parsed.body ? ' ' + parsed.body : ' ');
s.receipt = ''; paint(); return;
}
if (event.target.id === 'chat-session' && current && UUID.test(event.target.value)) {
if (idOf(event.target) === 'chat-session' && current && UUID.test(event.target.value)) {
location.hash = sessionPath(current.id, event.target.value);
}
});
@@ -1246,7 +1288,27 @@
if (!out() && current?.key === key) { await refresh(); paint(); }
}
}
document.addEventListener('mosaic-signed-out', () => { signedOut = true; forget(); });
on('mosaic-signed-out', () => { signedOut = true; forget(); });
const hasDraft = () => [...states.values()].some(s => Boolean(s.draft?.trim())) || [...forms.values()].some(f => Boolean(f.name?.trim() || f.repo || f.instanceChosen));
window.MosaicChat = Object.freeze({ render, leave, forget, projectPath, hasDraft });
// SP11: the unsent text of a pane's thread, and whether a write is in flight or a sent message
// still waits for the conversation to show it.
const draft = () => [...states.values()].find(s => s.draft?.trim())?.draft || '';
const busy = () => [...states.values()].some(s => s.pending || !!s.receiptId);
// Ends a pane instance: its listeners, reads and observers stop and its container is left as is.
function dispose() {
life.abort(); generation++; controller?.abort(); transcriptObserver?.disconnect(); transcriptResize?.disconnect();
current = null; lastPaint = null;
}
return { render, leave, forget, refresh, projectPath, hasDraft, draft, busy, dispose };
}
const main = chatInstance();
const ORG = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
let panes = 0;
// An Assistant pane: one thread of one organization, read and sent through that organization's own routes.
function pane(org) {
if (typeof org !== 'string' || !ORG.test(org)) throw new TypeError('pane needs an organization id');
const chat = chatInstance({ org, prefix: `chat-p${++panes}-` });
return Object.freeze({ render: chat.render, refresh: chat.refresh, dispose: chat.dispose, hasDraft: chat.hasDraft, draft: chat.draft, busy: chat.busy });
}
window.MosaicChat = Object.freeze({ render: main.render, leave: main.leave, forget: main.forget, projectPath: main.projectPath, hasDraft: main.hasDraft, pane });
})();
Loaded 100 of 179 files, more files were not shown because too many files have changed in this diff. Show more