// The unified workspace screens in organization mode: the sidebar's Organizations and Projects
// groups (sample 01), the organization dashboard (sample 03) and the Agents levels (sample 08).
// Every read goes through MosaicWorkspaceData (workspace-data.js). Nothing here writes; the bus
// restart button is console-restart.js's own control, with its gating and trail unchanged.
(() => {
'use strict';
if (!document.documentElement.hasAttribute('data-organizations')) return;
const data = window.MosaicWorkspaceData;
const esc = value => String(value ?? '').replace(/[&<>"']/g, c => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }[c]));
const enc = encodeURIComponent;
const GROUPING = 'mosaic-workspace-project-grouping-v1', ORGS_OPEN = 'mosaic-workspace-orgs-open-v1', PROJECTS_OPEN = 'mosaic-workspace-projects-open-v1';
const load = key => { try { return localStorage.getItem(key); } catch { return null; } };
const save = (key, value) => { try { localStorage.setItem(key, value); } catch {} };
let grouping = load(GROUPING) === 'flat' ? 'flat' : 'org';
let expanded = load(ORGS_OPEN) !== 'closed';
let projectsOpen = load(PROJECTS_OPEN) !== 'closed';
let orgs = null, orgError = false, themes = null, projects = new Map();
// Icons: the Console sprite where it has one, inline paths from the U0 sample where it does not.
const PATHS = {
folder: '',
columns: '',
chevron: '',
plus: '',
restart: '',
doc: '',
people: '',
cube: '',
};
const icon = (id, cls = '') => ``;
const LOGO = '';
// An organization's colour is its theme's action colour, per mode, with that mode's onAction for
// the initials. The CSS picks the pair for the page's mode (.ws-o in shell.css).
const HEX = /^#[0-9a-f]{6}$/i;
const themeOf = org => (themes || []).find(t => t.id === (org.theme || 'harbor')) || (themes || []).find(t => t.id === 'harbor');
function colours(org) {
const tokens = themeOf(org)?.tokens || {};
const pick = (mode, name, fallback) => (HEX.test(tokens[mode]?.[name] || '') ? tokens[mode][name] : fallback);
const l = [pick('light', '--action', '#2266bf'), pick('light', '--onAction', '#ffffff')];
const d = [pick('dark', '--action', '#74a6e7'), pick('dark', '--onAction', '#10141a')];
const m = [pick('dim', '--action', d[0]), pick('dim', '--onAction', d[1])];
return `--org-l:${l[0]};--org-on-l:${l[1]};--org-d:${d[0]};--org-on-d:${d[1]};--org-m:${m[0]};--org-on-m:${m[1]}`;
}
// Two words give their first letters (Distinctly Digital, DD); one word gives its first letter and
// its last consonant (Forge, FG; Home, HM), as the U0 sample marks them.
function initials(org) {
const words = String(org.label || org.id || '?').trim().split(/[\s_.-]+/).filter(Boolean);
if (words.length > 1) return (words[0][0] + words[1][0]).toUpperCase();
const word = words[0] || '?', rest = word.slice(1).replace(/[^a-z0-9]/gi, ''), consonants = rest.match(/[bcdfghjklmnpqrstvwxz]/gi);
return (word[0] + (consonants ? consonants[consonants.length - 1] : rest[0] || '')).toUpperCase();
}
const av = (org, size = '') => `${esc(initials(org))}`;
const label = org => org.label || org.id;
const state = org => (org.invalid ? ['s-error', '▲', 'invalid'] : org.busHealthy ? ['s-working', '●', 'bus running'] : org.busStopped ? ['s-offline', '○', 'bus stopped'] : ['s-offline', '○', 'bus unavailable']);
// A status mark: a glyph plus its word, shown or read aloud only.
const dot = (cls, glyph, word, shown = false) => `${glyph}${shown ? esc(word) : `${esc(word)}`}`;
const orgHref = id => `#/orgs/${enc(id)}`;
// SP3: a system route such as #/inbox has no organization prefix; both forms give the path.
const route = () => location.hash.replace(/^#(?:\/orgs\/[^/?]+)?/, '') || '/';
const ensureThemes = async () => { if (!themes) themes = await data.themes().then(b => (Array.isArray(b?.themes) ? b.themes : [])).catch(() => []); return themes; };
const instancesOf = value => { const v = value?.rows?.[0]?.instances ?? value?.instances; return v && typeof v === 'object' && !Array.isArray(v) ? v : null; };
// #1873 A3: the root and project agent copies the bus booted with, from the same instances read.
// An answer without the key (a bus with no copies, or one older than A3) gives an empty map.
const copiesOf = value => { const v = value?.rows?.[0]?.copies ?? value?.copies; return v && typeof v === 'object' && !Array.isArray(v) ? v : {}; };
const running = item => (Array.isArray(item?.running) ? item.running.length : 0);
const rowsOf = v => (Array.isArray(v) ? v : Array.isArray(v?.rows) ? v.rows : null);
// An agent's activity is the state the bus derives for the run holding its role. A live process
// alone says only running, never working or idle.
const ACTIVITY = { working: ['s-working', '●', 'working'], waiting: ['s-waiting', '◐', 'waiting on you'], idle: ['s-idle', '–', 'idle'] };
// SP11 (#1873): the agent counts share two words. Running is an agent row with a live process,
// whatever it is doing; working is a running one whose role session is working.
const LIVE_STATES = new Set(['working', 'waiting', 'idle', 'running']);
const runningOf = rows => rows.filter(a => LIVE_STATES.has(a.state)).length;
const workingOf = rows => rows.filter(a => a.state === 'working').length;
const agentNote = (run, waiting) => `${run} running${waiting ? `, ${waiting} waiting on you` : ''}`;
// SP13 (#1873): an instances answer that carries no runs for an agent (the bus gives `running` on
// every answer it enriches) has not said whether the agent runs, so its state reads as not read,
// never as not running.
const STATE_UNREAD = ['s-unknown', '?', 'state not read'];
const runsRead = item => Array.isArray(item?.running);
// SP14 (#1873): an instances answer in which no agent carries runs has not said what runs at all, so
// a count of running or working agents taken from it says not read, never 0. A copy that cannot
// launch has no runs to give and is left out.
const RUNS_WHY = 'the instance read did not say which agents run';
const runsUnread = (inst, copies = {}) => {
const all = [...Object.values(inst || {}), ...Object.values(copies || {}).filter(c => c && typeof c.name === 'string' && !copyBlocked(c))];
return all.length > 0 && !all.some(runsRead);
};
const activity = (name, item, agents) => {
if (!runsRead(item)) return STATE_UNREAD;
const on = running(item) > 0;
const held = on && agents ? agents.find(a => a?.role === name && item.running.includes(a.holder_run)) : null;
return ACTIVITY[held?.state] || (on ? ['s-working', '●', 'running'] : ['s-idle', '–', 'not running']);
};
// The inline model control: the change itself happens on Settings, Routing, with its own checks.
const modelCell = (agent, model) => (model ? `${esc(model)} Change` : 'not reported');
// Focus survives a repaint: the focused control's data-focus-key is found again afterwards.
const focusKey = root => { const a = document.activeElement; return root && a && root.contains(a) ? a.dataset?.focusKey || null : null; };
const refocus = (root, key) => { if (key) root.querySelector(`[data-focus-key="${CSS.escape(key)}"]`)?.focus({ preventScroll: true }); };
// ---------- sidebar (sample 01) ----------
function projectLinks(org, flat) {
const rows = projects.get(org.id);
if (rows === undefined) return flat ? '' : '
`;
}
// E2E6 P1-1: a poll repaints the whole page, which would drop an editor's draft and its focus. A
// section marked data-live-key that is being edited (it holds [data-live-hold] or [data-live-dirty])
// or holds focus is kept: holdLive takes it before the repaint and graftLive puts that same node, with
// its typed values, caret and focus, in place of its fresh counterpart. Each editor saves against the
// revision it started from, so a kept node cannot overwrite a change it never saw.
const TYPING = 'input:not([type=button],[type=submit],[type=reset],[type=checkbox],[type=radio]),select,textarea';
function holdLive(root) {
const held = new Map(), a = document.activeElement;
if (!root) return { held, active: null };
// Focus alone holds a section only while it sits in a field being typed in. A focused button or link
// is rebuilt with fresh data and gets its focus back through data-focus-key (review P3), so a section
// never stays stale just because its Apply button kept focus.
const typing = a?.matches?.(TYPING) ?? false;
for (const el of root.querySelectorAll('[data-live-key]')) {
if (el.matches('[data-live-hold]') || el.querySelector('[data-live-hold],[data-live-dirty]') || (typing && el.contains(a))) held.set(el.dataset.liveKey, el);
}
const active = a && [...held.values()].some(el => el.contains(a))
? { el: a, caret: typeof a.selectionStart === 'number' ? [a.selectionStart, a.selectionEnd, a.scrollTop] : null } : null;
return { held, active };
}
function graftLive(root, kept) {
if (!root || !kept?.held?.size) return false;
for (const el of root.querySelectorAll('[data-live-key]')) {
const old = kept.held.get(el.dataset.liveKey);
if (old && old !== el) el.replaceWith(old);
}
const a = kept.active;
if (a && a.el.isConnected) {
a.el.focus({ preventScroll: true });
if (a.caret && typeof a.el.setSelectionRange === 'function') try { a.el.setSelectionRange(a.caret[0], a.caret[1]); a.el.scrollTop = a.caret[2]; } catch { /* not a text field */ }
}
return Boolean(a && a.el.isConnected);
}
// SP1: the reason an organization's bus can't be read, for its pages. `row` is its GET /api/workspace
// status (state, reason, boot), or null when that read gave none.
// A reason that only restates the heading ("the bus is not running", the server's fallback) is not
// repeated; the last start time, when read, still shows.
const restates = reason => /^the bus is not (running|answering)\.?$/i.test(reason.trim());
const downWhy = row => (row && row.state !== 'ok' && typeof row.reason === 'string' && row.reason ? `${row.reason}${row.boot?.at ? `, last start ${when(row.boot.at)}` : ''}` : '');
// #1873 SP2: this is the page's only bus banner (the shell's "Bus unavailable" hides on this page), so
// it carries the restart action where the Console allows it.
function downBanner(org, row) {
const stopped = org.busStopped === true;
const plain = row && row.state !== 'ok' && typeof row.reason === 'string' && row.reason && restates(row.reason);
const why = plain ? '' : downWhy(row);
const tail = plain
? (row.boot?.at ? ` Last start ${esc(when(row.boot.at))}.` : '')
: why ? ` Reason: ${esc(why)}.` : ' No reason was read.';
const restart = window.MosaicConsole?.busButton?.('Restart the bus') || '';
return `
${stopped ? 'The bus is not running.' : 'The bus is not answering.'} Nothing about ${esc(label(org))}'s agents or packs can be read until it ${stopped ? 'starts' : 'answers'}.${tail}
${restart ? `
${restart}
` : ''}
`;
}
async function dashboard(id = window.MosaicOrg.id, opts = {}) {
const why = 'ws-reload-why';
// Only an organization the membership list names is read; anything else reads nothing more.
const [listRead] = await Promise.all([data.organizations().catch(() => null), ensureThemes()]);
const list = Array.isArray(listRead) ? listRead : null;
const org = list?.find(o => o.id === id && !o.invalid);
if (!org) return `
Organization unavailable
${list ? 'This organization is not on your list.' : 'The organization list could not be read.'}
`;
// E2E6 P2-8: a stopped bus is not read for the bus-backed editors; each says the bus is stopped.
const stopped = !org.busHealthy && org.busStopped === true;
// SP8 (#1873): the cross-organization read scoped to this one gives the tiles' figures and, SP1,
// while the bus is down, the reason the banner above everything else says. It runs beside the
// organization's own reads, not after them.
const wsRead = data.workspace({ org: id, sections: ['sessions', 'projects', 'metrics'] }).catch(() => null);
// SP12: an agent row opens its drawer over this page; only an agent of this organization.
// SP13: it waits on its own instances read only until this page's reads have answered.
let pageRead; const page = new Promise(done => { pageRead = done; });
const drawerRead = agentDrawer(opts.q ?? queryOf(), { only: id, configIn: opts.configIn, page }).catch(() => '');
const reads = await Promise.allSettled([data.business(id), data.settings(id), data.instances(id), data.threads(id), data.projects(id), data.agents(id), data.claims(id), ...(stopped ? [] : [window.MosaicAutonomy?.load(id), window.MosaicPacks?.load(id), window.MosaicWorkflows?.load(id)])]);
pageRead();
const value = i => (reads[i].status === 'fulfilled' ? reads[i].value : null);
const business = value(0), settings = value(1), instances = instancesOf(value(2));
const threads = rowsOf(value(3)), projectRows = rowsOf(value(4));
const agents = rowsOf(value(5)), claims = rowsOf(value(6));
const docRead = business?.business ? await docs(id, business.business.projects).catch(() => ({ rows: [], failed: true })) : null;
const ws = await wsRead;
const wsRow = arr(ws?.orgs).find(r => r?.org === id) ?? null;
const downRow = org.busHealthy ? null : wsRow;
await window.MosaicConsole?.ready;
const name = esc(label(org));
const tracker = business?.business?.vars?.['tracker.kind'];
// Header: the bus restart is console-restart.js's button where the Console allows it, otherwise
// the same control, present and disabled, with the reason. SP7 (#1873): while the bus is down and
// the down banner carries the live restart, the header draws none, so the page has one.
const restart = window.MosaicConsole?.busButton?.('Restart bus', { stop: true, glyph: icon('restart') }) || '';
const offTitle = "Restarting the bus is the owner's trailed action, on a Console started with send and the action trail";
const stopTitle = "Stopping the bus is the owner's trailed action, on a Console started with send and the action trail";
const bus = restart ? (org.busHealthy ? `${restart}` : '') : ``;
// SP11 (#1873): the line beside the disabled reload says how a change to the organization file loads.
const reload = ``;
const [bcls, bglyph] = state(org);
const meta = `
Kind not recordedid ${esc(id)}Tracker: ${tracker ? esc(titleCase(tracker)) : 'not set'}${dot(bcls, bglyph, org.busHealthy ? `bus running, read ${clock()}` : org.busStopped ? `bus stopped, read ${clock()}` : `bus unavailable, read ${clock()}`, true)}The bus reads the organization file when it starts. To load a change to the file, restart the bus.
`;
const modelOf = inst => business?.business?.instances?.find(i => i?.instance === inst)?.vars?.model;
// SP11: the sessions are the running rows the tile counts: the organization's instances and the
// root and project copies its bus booted with. A copy shows its own name.
const copyLive = Object.entries(copiesOf(value(2))).filter(([, c]) => c && typeof c.name === 'string' && !copyBlocked(c) && running(c)).map(([key, c]) => [key, c, c.name]);
const live = instances ? [...Object.entries(instances).filter(([, item]) => running(item)).map(([key, item]) => [key, item, key]), ...copyLive] : null;
// The sessions heading and rows take their activity from the session list the tile counts, so the
// two never disagree. When the tile shows no figure they use the bus agents read instead; when
// that failed too, the heading says working was not read rather than a figure.
const tileAgents = orgAgents && !agentsWhy ? arr(ws.sessions).filter(x => x?.kind === 'role' && x.org === id && typeof x.role === 'string').map(x => ({ role: x.role, holder_run: x.run, state: x.state })) : agents;
const liveWorking = live ? live.filter(([key, item]) => activity(key, item, tileAgents)[2] === 'working').length : 0;
// A session's project and task is the thread its live run holds a claim on (thread.claims), not
// any older conversation of the same agent. A failed read says unavailable, never "none".
const sessionRows = (live || []).map(([agent, item, shown]) => {
const held = claims ? claims.filter(c => item.running.includes(c?.holder_run)) : null;
const first = held?.[0], thread = first && threads ? threads.find(t => t?.id === first.thread) : null;
const model = modelOf(agent), count = running(item), [acls, aglyph, aword] = activity(agent, item, tileAgents);
const more = held && held.length > 1 ? ` · ${held.length - 1} more` : '';
const where = held === null ? 'Conversation unavailable'
: !first ? 'No conversation held right now'
: thread ? `${esc(projectName(thread.project))}${esc(thread.name || thread.id)}${more}`
: threads ? `Conversation${esc(first.thread)}${more}` : 'Conversation unavailable';
const pick = `${id}:${agent}`, on = new URLSearchParams(opts.q?.toString?.() ?? queryOf().toString());
on.set('agent', pick);
return `
${secH('Settings', 'every setting, with where its value comes from')}
${settingsList(org, { business, settings, instances, noRuns, orgCount: list ? list.length : null })}
${await drawerRead}
`;
}
// ---------- agents levels (sample 08) ----------
// Root and organization agents come from their files through /api/agents/levels (#1873 A1, read
// only). Every status comes from the organization's bus: its instances, and since A3 the root and
// project agent copies it booted with. Nothing here invents a status, a model or a memory.
const NOT_RUNNING = ['s-idle', '–', 'not running'];
// SP1: why a bus-backed read gave nothing, in the membership list's words.
const busWord = org => (org?.busStopped === true ? 'the bus is stopped' : 'the bus is not answering');
// A copy's status: running or not as the bus reports its runs, or why it can't launch.
const CANT = ['s-error', '▲', "can't launch"];
// #1873 CB5: the bus adds `binding` to a copy that needs a credential binding: its status code and
// the owner's next step, fixed text from the bus. A booted copy whose binding is not ready can't
// launch, and says why.
const bindingNext = (c) => (typeof c?.binding?.next === 'string' && c.binding.status !== 'ready' ? c.binding.next : '');
const copyBlocked = (c) => c.state !== 'instance' || Boolean(bindingNext(c));
const copyWhy = (c) => (c.state === 'unbound' ? [`no binding in this organization for ${(c.missing || []).join(', ')}`, bindingNext(c)].filter(Boolean).join('. ')
: c.state === 'instance' ? bindingNext(c) : c.reason || 'refused');
const copyDot = (name, c, agents) => (copyBlocked(c) ? CANT : activity(name, c, agents));
// The bus names each copy's instance. Find an agent's copy by its name and project, never by
// rebuilding the instance name: a collision refuses one entry that lists every claimant.
const copyFor = (copies, name, project = null) => {
const mine = c => c && c.name === name && (c.project ?? null) === project;
const hit = Object.entries(copies || {}).find(([, c]) => mine(c) || (Array.isArray(c?.claims) && c.claims.some(mine)));
return hit ? { key: hit[0], copy: hit[1] } : { key: null, copy: null };
};
const LEVEL_CLS = { root: 'root', org: 'org', project: 'proj' };
// SP5: what an agent is, in words. A hired agent's definition is `org:hire-`. No read names
// the template it was hired from, so it reads as hired, and from which pack when a pack hired it;
// the definition id stays as secondary text.
const isHired = item => typeof item?.hireDecision === 'string' || /^org:hire-/.test(String(item?.definition ?? ''));
const packOf = item => (typeof item?.pack?.label === 'string' && item.pack.label ? item.pack.label : typeof item?.pack?.id === 'string' ? item.pack.id : '');
const ROLE_WORD = { 'chief-of-staff': 'Chief of staff', assistant: 'Assistant' };
const roleWords = item => {
const d = typeof item?.definition === 'string' ? item.definition : '';
if (isHired(item)) return packOf(item) ? `Hired from pack ${packOf(item)}` : 'Hired';
return ROLE_WORD[d] || d.replace(/^org:/, '') || 'not reported';
};
const projectName = (rows, id) => { const p = Array.isArray(rows) ? rows.find(r => r?.id === id) : null; return p?.name || id; };
let agentsPick = null; // the project chosen in "Available in a project", kept across repaints
// Repaints that section alone when the choice changes, one renderer per organization: a side-by-side
// pane can show another organization's agents next to the page's own.
let agentsAvailable = {};
function levelsTable(ctx, projectId) {
const { selOrg, lv, mine, levels, modelOf, names, others } = ctx;
const union = projectId && lv?.state === 'ok' ? lv.projects[projectId] : null;
if (union && union.state !== 'ok') return `
The agents for ${esc(names(projectId))} could not be resolved. ${esc(union.reason)}
`;
const set = union || (lv?.state === 'ok' ? lv.base : null);
const inst = mine?.inst ?? null;
const rows = [];
if (levels?.root?.state === 'ok' && levels.root.assistant) {
// The model the root file sets is shown as configured; the assistant's running state is not reported.
const configured = levels.root.agents.find(a => a.name === levels.root.assistant)?.model ?? null;
rows.push({ name: levels.root.assistant, level: 'root', definition: 'assistant', model: configured, scope: { kind: 'cross-org' }, overrides: [], narrowed: [], assistant: true });
}
if (set) {
rows.push(...set.agents);
// A bus instance the organization file no longer names still shows, as the bus reports it.
const known = new Set([...set.agents.map(a => a.name), ...set.excluded.map(e => e.name)]);
for (const name of Object.keys(inst || {})) if (!known.has(name)) rows.push({ name, level: 'org', definition: inst[name]?.definition, model: null, scope: { kind: 'org' }, overrides: [], narrowed: [] });
} else if (inst) {
rows.push(...Object.entries(inst).map(([name, v]) => ({ name, level: 'org', definition: v?.definition, model: null, scope: { kind: 'org' }, overrides: [], narrowed: [] })));
}
if (!set && inst === null) return `
${selOrg?.busHealthy === false ? `Agents not read: ${busWord(selOrg)}.` : 'Agents unavailable. The bus did not answer the instance read.'}
`;
if (!rows.length) return '
No agents configured
';
const where = a => (a.level === 'root' ? 'Your root configuration' : a.level === 'org' ? `${label(selOrg)} file` : `${names(a.project)} project`);
const hired = a => a.level === 'org' && isHired({ ...inst?.[a.name], definition: a.definition });
const sub = a => [hired(a) ? 'hired' : a.definition && a.definition !== a.name ? a.definition : '', a.level === 'org' && typeof inst?.[a.name]?.pack?.id === 'string' ? `from pack ${inst[a.name].pack.id}` : '', hired(a) ? a.definition : '', a.overrides?.length ? `replaces the ${a.overrides.map(o => (o.level === 'org' ? 'organization' : o.level)).join(' and ')} ${a.overrides.length > 1 ? 'definitions' : 'definition'}` : '', a.narrowed?.length ? `narrowed here: ${a.narrowed.join(', ')}` : ''].filter(Boolean).join(' · ');
const status = a => {
if (a.assistant) return dot('s-unknown', '?', 'status not reported', true);
if (a.level !== 'org') {
if (inst === null) return 'status unavailable';
const { key, copy: c } = copyFor(mine?.copies, a.name, a.level === 'project' ? a.project : null);
if (!c) return 'starts with the next bus start';
return `${dot(...copyDot(key, c, mine.agents), true)}${copyBlocked(c) ? `${esc(copyWhy(c))}` : ''}`;
}
if (inst === null) return 'status unavailable';
return dot(...(inst[a.name] ? activity(a.name, inst[a.name], mine.agents) : NOT_RUNNING), true);
};
const model = a => {
if (a.level === 'org') return modelCell(a.name, modelOf(a.name) ?? a.model);
return a.model ? esc(a.model) : 'not set';
};
const body = rows.map(a => { const s = sub(a); return `
${esc(a.name)}${s ? `${esc(s)}` : ''}
${a.level}
${esc(where(a))}
${a.scope?.kind === 'cross-org' ? 'Shared across all organizations' : 'This organization only'}
${status(a)}
${model(a)}
`; }).join('');
// What this project does not get: other projects' own agents, its exclusions and other organizations.
const away = [];
if (union) {
const here = new Set(union.agents.map(a => a.name));
for (const [pid, entries] of Object.entries(lv.defined || {})) if (pid !== projectId) for (const e of entries) if (e.form === 'define' && !here.has(e.name)) away.push(`${e.name} (${names(pid)} only)`);
}
if (set) {
for (const e of set.excluded) away.push(`${e.name} (${e.by === 'project' ? 'excluded in this project' : `turned off for ${label(selOrg)}`})`);
}
const otherOrgs = others.map(o => label(o));
const tail = otherOrgs.length ? `every ${otherOrgs.length > 1 ? `${otherOrgs.slice(0, -1).join(', ')} or ${otherOrgs.at(-1)}` : otherOrgs[0]} agent` : '';
const parts = [...away, tail].filter(Boolean);
const note = parts.length ? `
Not available here: ${esc(parts.length > 1 ? `${parts.slice(0, -1).join(', ')} and ${parts.at(-1)}` : parts[0])}.
` : '';
return `
Agent
Level
Defined in
Memory
Status
Model
${body}
${note}`;
}
// SP5: `opts.under` draws it below the scoped Agents table (#/orgs//agents), which owns the page heading.
async function agentGrid(note = '', selected = window.MosaicOrg?.id, opts = {}) {
const [list, levels] = await Promise.all([data.organizations().catch(() => null), data.agentLevels().catch(() => null), ensureThemes()]);
const head = `
Agents are defined at three levels: root, organization and project. Each organization runs its own copy of a root agent, and a project's agents run only in that project. The copies are made when the organization's bus starts.${note ? ` ${note}` : ''}
${LOGO}assistantroot${dot('s-unknown', '?', 'status not reported', true)}Works across${valid.map(org => av(org)).join('')}The assistant talks with you across organizations. Its status is not reported on this page; set it up under Settings, Assistant.
`;
const endc = i => (i === results.length - 1 ? ' endc' : '');
// Ruling 2026-11-14: a card names the pack that hired its agent, and the page's own organization
// offers Fire on every card but the chief's and the assistant's (bus.js draws the control and its confirmation).
const pill = (org, name, item, agents) => {
const cos = item?.definition === 'chief-of-staff' || name === 'chief';
const [acls, aglyph, aword] = activity(name, item, agents);
const from = typeof item?.pack?.id === 'string' ? ` from pack ${esc(item.pack.id)}` : '';
// No Fire the bus would refuse: the assistant (and any end-protected instance) is never fired.
const fire = cos || item?.definition === 'assistant' || item?.endProtected === true ? '' : window.MosaicDecide?.fireControl(org.id, name) ?? '';
return `${dot(acls, aglyph, aword)}${esc(name)}${cos && name !== 'chief' ? ' chief' : ''}${from}${fire}`;
};
// A root or project copy in one organization's cell: its status from that organization's bus, and
// why it can't launch when it can't. No answer from the bus reads as unavailable, never as idle.
const copyPill = (copies, agents, name, project, small) => {
const { key, copy: c } = copyFor(copies, name, project);
const mark = copies === null ? ['s-unknown', '?', 'status unavailable'] : !c ? ['s-unknown', '?', 'starts with the next bus start'] : copyDot(key, c, agents);
const why = c && copyBlocked(c) ? `${esc(name)}: ${esc(copyWhy(c))}` : '';
return `${dot(...mark)}${esc(name)} ${esc(small)}${why}`;
};
// Root: one copy per organization, each running inside that organization; an opt-out is said.
const root = levels?.root;
const rootRow = !root ? '
Root agents unavailable. The levels read did not answer.
`;
}
document.addEventListener('change', e => {
const select = e.target.closest?.('[data-agents-project]');
const org = select?.dataset.agentsProject, draw = org && Object.hasOwn(agentsAvailable, org) ? agentsAvailable[org] : null;
const box = draw && select.closest('[data-org-agents]')?.querySelector('[data-agents-available]');
if (!box) return;
agentsPick = { ...agentsPick, [org]: select.value };
box.innerHTML = draw(select.value);
});
// ---------- across organizations (U3: samples 02, 04 and 05) ----------
// One read, GET /api/workspace (U1), backs the three pages. Each organization carries a state and
// the time it was read: one that is down, starting or slow is named with that state, and the rest
// still render. Filters live in the page's hash query, so a poll repaints the same view and a
// link reproduces it. Numbers come only from the read; a field no read gives is one honest line.
let pollMs = 10000;
const took = body => { const n = Number(body?.pollMs); if (Number.isFinite(n) && n >= 1000) pollMs = n; return body; };
const selHref = path => `#/orgs/${enc(window.MosaicOrg?.id || '')}${path}`;
const ORG_STATE = { ok: ['s-working', '●', 'running'], starting: ['s-waiting', '◐', 'starting'], down: ['s-offline', '○', 'down'], timeout: ['s-error', '▲', 'not answering'], invalid: ['s-error', '▲', 'invalid'] };
const orgState = o => ORG_STATE[o?.state] || ['s-unknown', '?', 'not reported'];
const msOf = iso => { const t = Date.parse(iso || ''); return Number.isFinite(t) ? t : null; };
const hm = iso => { const t = msOf(iso); return t === null ? '' : new Date(t).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }); };
// Today's times as HH:MM, older ones as a short date.
const when = iso => { const t = msOf(iso); if (t === null) return ''; const d = new Date(t); return d.toDateString() === new Date().toDateString() ? hm(iso) : d.toLocaleDateString([], { month: 'short', day: 'numeric' }); };
const span = iso => { const t = msOf(iso); if (t === null) return ''; const m = Math.max(0, Math.floor((Date.now() - t) / 60000)); return m < 1 ? 'under a minute' : m < 60 ? `${m} min` : m < 2880 ? `${Math.floor(m / 60)} h` : `${Math.floor(m / 1440)} days`; };
const ago = iso => { const s = span(iso); return !s ? '' : s === 'under a minute' ? 'just now' : `${s} ago`; };
const num = v => (Number.isFinite(v) ? v : 0);
const arr = v => (Array.isArray(v) ? v : []);
// The organizations the read names, with their colours, marks and states.
function orgsOf(body) {
const rows = arr(body?.orgs).filter(o => o && typeof o.org === 'string');
// The read names an organization by id; the sidebar's list carries its display label.
const known = id => (Array.isArray(orgs) ? orgs.find(x => x?.id === id) : null);
const byId = new Map(rows.map(o => [o.org, { id: o.org, label: known(o.org)?.label || o.label || o.org, theme: o.theme ?? known(o.org)?.theme ?? null }]));
const meta = id => byId.get(id) || { id, label: id };
return {
rows, meta, name: id => label(meta(id)), style: id => colours(meta(id)),
ref: (id, cls = '') => `${av(meta(id))}${esc(label(meta(id)))}`,
unread: rows.filter(o => o.state !== 'ok'),
};
}
const stateWords = o => `${esc((Array.isArray(orgs) ? orgs.find(x => x?.id === o.org)?.label : null) || o.label || o.org)} ${orgState(o)[2]}${o.at ? `, read ${hm(o.at)}` : ''}`;
const andList = items => (items.length < 2 ? items.join('') : `${items.slice(0, -1).join(', ')} and ${items[items.length - 1]}`);
// An organization that answered can still fail one read (errors in GET /api/workspace). The page
// names that organization and the reason rather than count the read as zero.
const READ_WHY = { 'channel-disabled': 'the chat channel is off', 'outcome-unknown': 'no answer', timeout: 'no answer in time' };
const missOf = (r, names) => { const n = r?.state === 'ok' && r.errors ? names.find(x => r.errors[x]) : null; return n ? READ_WHY[r.errors[n]] || String(r.errors[n]) : null; };
const missed = (o, names) => o.rows.filter(r => missOf(r, names)).map(r => `${esc(o.name(r.org))} (${esc(missOf(r, names))})`);
const missLine = (o, names, key, lead = 'Not read in') => { const m = missed(o, names); return m.length ? `
${lead} ${andList(m)}.
` : ''; };
// SP3/SP4: a row's organization and project as chips, and the organizations that did not answer
// named first with the reason their read gave. The Inbox and the system task board share these.
// `mark`, already-escaped markup such as the organization's avatar, takes the dot's place.
const orgChip = (o, id, mark = '') => `${mark}${esc(o.name(id))}`;
const projChip = name => (name ? `${esc(name)}` : '');
const unreadWhy = r => `${stateWords(r).replace(/, read .*$/, '')}${r.reason ? `: ${esc(r.reason)}` : ''}${r.at ? ` (read ${esc(hm(r.at))})` : ''}`;
const unreadNote = (o, names, key) => (o.unread.length ? `
Not read: ${andList(o.unread.map(unreadWhy))}.
` : '') + missLine(o, names, key);
// The organizations that answered and made every read a figure is built from. Only these count
// toward it: a failed read reaches the merge as an empty list, so its zero is not a figure.
const readers = (o, names) => new Set(o.rows.filter(r => r.state === 'ok' && !missOf(r, names)).map(r => r.org));
// Some organizations exist, and none of them could make these reads.
const noneRead = (o, names) => o.rows.length > 0 && !readers(o, names).size;
function failedPage(cls, attr, title, err) {
const why = err?.status === 403 ? 'This Console refused the read across organizations.' : err?.status === 0 ? 'You are signed out. Reload the page to sign in again.' : err?.status === 400 ? 'The read refused these filters. Clear them and try again.' : 'The read across organizations did not answer. The page tries again on its next refresh.';
return `
${title}
${why}
`;
}
// The Inbox count in the navigation follows the cross-organization read wherever it was made.
// SP3: the sidebar's Inbox count on a page that reads one organization (the board) comes from the
// workspace read too, so it says what #/inbox lists. A failed read leaves the count as it was.
const inboxCount = () => data.workspace({ sections: ['inbox'] }).then(b => { if (!noneRead(orgsOf(b), ['inbox'])) tellInbox(arr(b.inbox).filter(d => d && typeof d.org === 'string')); }).catch(() => {});
const newest = (a, b) => (b.at ?? '').localeCompare(a.at ?? '');
const tellInbox = rows => { if (Array.isArray(rows)) document.dispatchEvent(new CustomEvent('mosaic-workspace-inbox', { detail: { open: rows.length, blocking: rows.filter(d => d?.blocking).length } })); };
// A stacked bar and its per-organization figures, one segment per organization.
const bar = (o, parts, style = '') => `
`;
// Why an organization's instances read gave nothing, in a word or two.
const READ_ERR = { 401: 'signed out', 403: 'refused', 0: 'signed out' };
const instWhy = r => READ_ERR[r.err?.status] || r.err?.code || 'no answer';
// SP8 (#1873): one KPI tile, a link to the page that lists what it counts. A tile with no figure
// (`big` null) is drawn quiet with `none` in its place; `miss` names the organizations the figure
// leaves out, already escaped. The figure is never shown as complete while one is missing.
const kpiTile = (o, { key, name, href, big = null, small = '', parts = null, delta = '', miss = [], none = 'Not read', attrs = '' }) => {
const quiet = big == null;
const left = miss.length ? `${quiet ? '' : 'Not read in '}${andList(miss)}` : '';
const head = `${name}`;
if (quiet) return `${head}${none}${left}`;
return `${head}${big}${small ? ` ${small}` : ''}${parts ? bar(o, parts) + by(o, parts) : ''}${delta ? `${delta}` : ''}${left}`;
};
const CLASS_CHIP = { gated: 'gated', 'within-role': 'within', routine: 'routine', 'cross-role': 'cross' };
// The one map of decision classes to words: the class chips and the Inbox Class filter both read it.
const TYPE_WORD = { gated: 'Gated', 'within-role': 'Within role', 'cross-role': 'Cross-role', routine: 'Routine' };
// SP11: the Inbox's word for a decision class; a class the map does not know shows as it is.
const classWord = c => (Object.hasOwn(TYPE_WORD, c) ? TYPE_WORD[c] : c);
const classChip = c => (c ? `${esc(classWord(c))}` : '');
const itemKey = d => `${d.org}:${d.id}`;
const roleOf = d => d.session?.role || d.raisedBy || '';
const fromWords = (o, d, withOrg = true) => [withOrg ? o.name(d.org) : '', d.project?.name || 'No project', roleOf(d)].filter(Boolean).map(esc).join(' · ');
// ---- main dashboard (sample 02) ----
async function home() {
let body;
let levels = null, listed = null;
// SP1: the agent counts come from the organization files (GET /api/agents/levels, owner only), so a
// stopped bus still has one; the bus state words come from the membership list. Either read may
// fail or be absent, and its column then shows no figure.
try { [body, levels, listed] = await Promise.all([data.workspace({ sections: ['projects', 'sessions', 'inbox', 'tasks', 'metrics'] }), data.agentLevels().catch(() => null), data.organizations().catch(() => null), ensureThemes()]); took(body); }
catch (err) { return failedPage('ws-home', 'data-ws-home', 'Dashboard', err); }
const o = orgsOf(body), m = body.metrics, t = m?.totals, per = arr(m?.orgs);
const inbox = arr(body.inbox), sessions = arr(body.sessions), projectRows = arr(body.projects), tasks = arr(body.tasks);
if (!noneRead(o, ['inbox'])) tellInbox(body.inbox);
// The reads each tile's figures come from (workspace-read.mjs orgRows).
const SRC = { needs: ['inbox'], sessions: ['agents', 'claims'], tasks: ['tasks'], done: ['tasks'], projects: ['projects'] };
const listRow = id => (Array.isArray(listed) ? listed.find(x => x?.id === id) : null);
// The bus state as the workspace read found it; "stopped" only when the membership list says the owner stopped it.
const ROW_STATE = { ok: ['s-working', '●', 'bus running'], starting: ['s-waiting', '◐', 'bus starting'], timeout: ['s-error', '▲', 'bus not answering'], invalid: ['s-error', '▲', 'invalid'] };
const rowState = (r, fromList) => (r.state === 'down' ? ['s-offline', '○', fromList?.busStopped === true ? 'bus stopped' : 'bus down'] : ROW_STATE[r.state] || orgState(r));
// SP8 (#1873): one row of tiles, each a link to the page that lists what it counts. A figure adds up
// only the organizations whose reads gave it, and its tile names the rest: one that did not answer
// by its bus state, one that answered but failed a read by that read's reason.
const offWord = r => rowState(r, listRow(r.org))[2];
const notIn = names => [...o.unread.map(r => `${esc(o.name(r.org))} (${offWord(r)})`), ...missed(o, names)];
const parts = (key, f) => { const ok = readers(o, SRC[key]); return per.filter(x => ok.has(x.org)).map(x => ({ id: x.org, n: num(f(x)) })); };
const sum = ps => ps.reduce((a, p) => a + p.n, 0);
const fig = (key, ps) => (m && readers(o, SRC[key]).size ? sum(ps) : null);
// A response with no metrics section leaves every figure tile quiet; it says so rather than a bare "Not read".
const noFig = m ? {} : { none: 'Not read: no figures were read' };
const answered = o.rows.filter(r => r.state === 'ok').length;
// Agents working of all agents: the system Agents page's rows, read the way that page reads them.
// An organization whose agent read failed is named, never counted as having none.
const agentReads = await readInstances(o.rows.filter(r => r.state === 'ok' && !missOf(r, ['agents'])).map(r => r.org));
const agentOk = agentReads.filter(r => r.inst), agentAll = agentRows(agentOk, body);
// SP14 (#1873): an organization whose instances answer carries no runs adds nothing to the running
// and working figures; the tile names it, and its row says running was not read.
const runOk = agentOk.filter(r => !runsUnread(r.inst, r.copies)), runRows = agentAll.filter(a => runOk.some(r => r.id === a.org));
const agentParts = runOk.map(r => ({ id: r.id, n: runRows.filter(a => a.org === r.id && a.state === 'working').length }));
const waitingOn = runRows.filter(a => a.state === 'waiting').length;
const ps = { needs: parts('needs', x => x.needsYou), tasks: parts('tasks', x => x.openTasks), done: parts('done', x => x.doneThisWeek), projects: parts('projects', x => x.projects?.active) };
const needsN = fig('needs', ps.needs);
const archived = per.filter(x => readers(o, SRC.projects).has(x.org)).reduce((a, x) => a + num(x.projects?.archived), 0);
const tiles = !o.rows.length ? '
No organizations yet, so there is nothing to count.
${noneRead(o, ['tasks']) ? 'Tasks not read' : 'No open tasks'}
`;
// SP3: the same order as #/inbox, newest first, so these five are the Inbox's top five.
const needs = inbox.slice().sort(newest).slice(0, 5);
const needsList = needs.length ? `
${noneRead(o, ['agents', 'claims']) ? 'Sessions not read' : `No session working right now${idle ? `; ${plural(idle, 'idle session')}` : ''}`}
`;
const total = t ? num(t.projects?.active) + num(t.projects?.archived) : null;
const allRead = !o.unread.length;
const sub = !o.rows.length ? 'You belong to no organization yet.'
: allRead ? `All ${plural(o.rows.length, 'organization')}${missed(o, ['projects']).length ? '' : ` and ${plural(total ?? 0, 'project')}`}. Totals add up every organization you belong to; each tile breaks them down by organization.`
: `${body.summary?.read ?? o.rows.length - o.unread.length} of ${plural(o.rows.length, 'organization')} answered. Totals add up the ones that answered; ${andList(o.unread.map(stateWords))}.`;
return `
Dashboard
${sub}
${tiles}
${secH('Organizations', `read ${esc(hm(body.readAt))}`, '', 'tabindex="-1" data-ws-orgs-h data-focus-key="orgs-h"')}
${orgList}
${secH('Recent project activity', 'latest change per project; there is no activity feed yet', `All projects`)}
${trail}${missLine(o, ['projects'], 'recent')}
${secH('Tasks by state', 'open tasks, every tracker', 'Open tasks')}
${states}${missLine(o, ['tasks'], 'states')}
${secH('Needs you', '', 'Inbox')}
${needsList}${missLine(o, ['inbox'], 'needs')}
${secH('Active agents', 'sessions now', 'Agents')}
${sessTable}${missLine(o, ['agents', 'claims'], 'sessions')}
`;
}
// ---- projects across organizations (sample 04, REQ-WS-5) ----
const ORG_ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
const listParam = (q, key, ok) => { const v = [...new Set(String(q?.get?.(key) || '').split(',').map(s => s.trim()).filter(ok))]; return v.length ? v : null; };
// The hash query, cleaned to what the API accepts, so a hand-edited link never reads as "all".
function projectQuery(q) {
const sort = ['activity', 'name', 'org', 'status'].includes(q?.get?.('sort')) ? q.get('sort') : 'activity';
const order = ['asc', 'desc'].includes(q?.get?.('order')) ? q.get('order') : sort === 'activity' ? 'desc' : 'asc';
const name = String(q?.get?.('name') || '').trim().slice(0, 200);
return {
org: listParam(q, 'org', id => ORG_ID.test(id)), status: listParam(q, 'status', s => ['active', 'archived'].includes(s)) || ['active'],
state: listParam(q, 'state', s => ['working', 'waiting', 'idle', 'none'].includes(s)), name: name || null, sort, order,
};
}
const SORT_WORD = { activity: 'latest activity', name: 'name', org: 'organization', status: 'status' };
const STATUS_OPTS = [['active', 'Active'], ['archived', 'Archived'], ['active,archived', 'Active and archived']];
const STATE_OPTS = [['', 'Any session state'], ['working', 'Working'], ['waiting', 'Waiting on you'], ['idle', 'Idle'], ['none', 'No session']];
function orgChips(o, counts, chosen, total, src = []) {
const all = !chosen;
return `
`;
}
// ---- inbox across organizations (sample 05; SP3 prototype 1114 /inbox) ----
// SP3: #/inbox lists every organization's items from one read (GET /api/workspace), newest first,
// each row with its organization chip and a project chip when it has one. The organization and type
// filters live in the hash query and run on that read, so the chip counts, the sidebar count and the
// dashboard's Needs you agree. `opts.scope` is the organization of #/orgs//inbox: the same list,
// filtered to it. `opts.answer(d)` returns the answer panel bus.js builds in the row's own
// organization; `opts.answered(key)` keeps its receipt after the row leaves the list. `opts.hire`: a
// function that returns the hire, fire and change form bus.js builds for the current organization
// (D4, P0-1), shown on the scoped list only. It is called after the read so typing or a submit
// result that lands during the read is not painted over with an older draft.
const TYPE_RE = /^[a-z][a-z-]{0,31}$/;
async function inboxPage(q, opts = {}) {
const scope = typeof opts.scope === 'string' && ORG_ID.test(opts.scope) ? opts.scope : null;
const org = scope ? [scope] : listParam(q, 'org', id => ORG_ID.test(id));
const type = TYPE_RE.test(String(q?.get?.('type') || '')) ? q.get('type') : null;
const want = String(q?.get?.('d') || '');
let body;
try { [body] = await Promise.all([data.workspace({ sections: ['inbox'] }), ensureThemes()]); took(body); }
catch (err) { return failedPage('ws-inbox', 'data-ws-inbox', 'Inbox', err); }
const every = orgsOf(body), everyRows = arr(body.inbox).filter(d => d && typeof d.org === 'string');
if (!noneRead(every, ['inbox'])) tellInbox(everyRows);
const counts = new Map();
for (const d of everyRows) counts.set(d.org, (counts.get(d.org) || 0) + 1);
// The organizations in view: every one, or the chosen ones.
const o = org ? { ...every, rows: every.rows.filter(r => org.includes(r.org)), unread: every.unread.filter(r => org.includes(r.org)) } : every;
const inOrg = everyRows.filter(d => !org || org.includes(d.org)).sort(newest);
const rows = inOrg.filter(d => !type || d.class === type);
const picked = want === 'none' ? null : rows.find(d => itemKey(d) === want) || (want ? null : rows[0] || null);
const here = path => (scope ? `${orgHref(scope)}${path}` : `#${path}`);
const qs = d => { const p = new URLSearchParams(); if (org && !scope) p.set('org', org.join(',')); if (type) p.set('type', type); p.set('d', d ? itemKey(d) : 'none'); return here(`/inbox?${p}`); };
const chips = d => `${orgChip(o, d.org)}${projChip(d.project?.name)}`;
const row = d => {
const on = picked && itemKey(d) === itemKey(picked), by = roleOf(d);
return `
`;
};
// An organization that did not answer is named first, with the reason its read gave.
const unread = unreadNote(o, ['inbox'], 'inbox');
const filtered = (org && !scope) || type;
const table = rows.length ? `
Items that need you
Needs
Class
Waiting
${rows.map(row).join('')}
` : `
${noneRead(o, ['inbox']) ? 'Decisions not read' : filtered ? 'Nothing matches these filters' : 'Nothing needs you'}
`;
// The hire, fire and change form posts to one organization's bus, so the system list links to
// each answering organization's own Inbox, where the form is: only those whose own config says this
// Console decides there, never judged by the organization opened last (its bus may be the stopped one).
// Read before the answer panel: its HTML must be the last thing this render waits for, so a
// confirmation shown while another read was in flight is never painted over with an older panel.
const asks = typeof opts.hireIn === 'function' && !scope ? o.rows.filter(r => r.state === 'ok') : [];
const hiring = (await Promise.all(asks.map(async r => ((await opts.hireIn(r.org)) === true ? r : null)))).filter(Boolean);
let insp = '';
if (picked) {
const d = picked, id = esc(d.id);
const decideHref = `${orgHref(d.org)}/inbox/${enc(d.id)}`;
const answerHtml = (await opts.answer?.(d)) || '';
const choices = arr(d.options);
const optList = choices.length ? `
The inbox mixes organizations, so the copied command always names the organization's bus.
` : '
No terminal command for this item: its id or options cannot be passed to a shell safely.
';
const by = roleOf(d);
insp = ``;
} else if (want && want !== 'none') {
// The answered row has left the list; its receipt stays until another row is chosen.
const kept = opts.answered?.(want) || '';
if (kept) insp = ``;
}
// Type chips: the decision classes the read carries, in the organizations in view.
const typeCounts = new Map();
for (const d of inOrg) if (typeof d.class === 'string' && TYPE_RE.test(d.class)) typeCounts.set(d.class, (typeCounts.get(d.class) || 0) + 1);
const types = [...new Set([...typeCounts.keys(), ...(type ? [type] : [])])].sort();
const typeChips = `
Class${types.map(c => ``).join('')}
`;
const hireIn = hiring.length ? `
Hire, fire or change an agent in ${andList(hiring.map(r => `${esc(o.name(r.org))}`))}.
` : '';
const orgsWith = new Set(rows.map(d => d.org)).size;
const tally = rows.length ? ` ${plural(rows.length, 'item')}${scope ? '' : ` from ${plural(orgsWith, 'organization')}`}.` : '';
const sub = scope
? `Items from ${esc(o.name(scope))} only.${tally} Every organization`
: `Everything waiting on you, from every organization.${tally} An item leaves only when it is answered.`;
return `
`;
}
// ---- agents across organizations (#1873 SP5, prototype shot 14) ----
// One table of every organization's agents: the organization's own instances and the root and
// project copies its bus booted with, from each organization's instances read; what each one works
// on from the workspace read's role sessions. Filters by organization and state live in the hash.
// `opts.scope` names one organization (#/orgs//agents): the same table, that organization only.
// `opts.fireIn(org)` says from that organization's own config whether this Console decides there;
// Fire is drawn only on the system page and only there, and posts to the row's organization (bus.js).
const AGENT_STATE = [['working', 'Working'], ['waiting', 'Waiting on you'], ['idle', 'Idle'], ['running', 'Running, state unknown'], ['not-running', 'Not running'], ['not-read', 'State not read'], ['cant-launch', "Can't launch"]];
const AGENT_STATE_KEY = { working: 'working', 'waiting on you': 'waiting', idle: 'idle', running: 'running', 'not running': 'not-running', 'state not read': 'not-read', "can't launch": 'cant-launch' };
// Each named organization's instances read, and whether this Console decides there when `fireIn` is given.
const readInstances = (ids, fireIn) => Promise.all(ids.map(id => Promise.all([
data.instances(id).then(v => ({ inst: instancesOf(v), copies: copiesOf(v) }), err => ({ inst: null, copies: {}, err })),
typeof fireIn === 'function' ? fireIn(id).then(v => v === true, () => false) : false,
]).then(([v, fire]) => ({ id, ...v, fire }))));
// The agent rows of every organization whose instances read answered: its own instances and the root
// and project copies its bus booted with, each in the state the system Agents page shows. SP8: the
// Dashboard and organization tiles count these same rows, so a tile's figure is the page's row count.
function agentRows(reads, body) {
const sessions = arr(body?.sessions).filter(x => x?.kind === 'role' && typeof x.org === 'string' && typeof x.role === 'string');
const projects = arr(body?.projects).filter(x => typeof x?.org === 'string');
const projectRef = (id, p) => { const hit = projects.find(x => x.org === id && (x.id === p || x.key === p)); return hit ? { id: hit.id, name: hit.name || hit.key || hit.id } : { id: p, name: p }; };
const all = [];
for (const r of reads) {
if (!r.inst) continue;
const mine = sessions.filter(x => x.org === r.id);
const agents = mine.map(x => ({ role: x.role, holder_run: x.run, state: x.state }));
const session = name => mine.find(x => x.role === name) || null;
for (const [name, item] of Object.entries(r.inst)) {
const d = activity(name, item, agents);
// Never Fire the chief, the assistant or an instance the bus would refuse to end.
const keep = item?.definition === 'chief-of-staff' || name === 'chief' || item?.definition === 'assistant' || item?.endProtected === true;
all.push({ org: r.id, key: name, name, level: 'org', role: roleWords(item), id: isHired(item) ? item.definition : '', dot: d, s: session(name), fire: r.fire && !keep, keep, item });
}
for (const [key, c] of Object.entries(r.copies || {})) {
if (!c || typeof c.name !== 'string') continue;
const d = copyDot(key, c, agents);
all.push({ org: r.id, key, name: c.name, level: c.level === 'project' ? 'project' : 'root', role: roleWords(c), id: copyBlocked(c) ? copyWhy(c) : '', dot: d, s: session(key), project: c.level === 'project' && c.project ? projectRef(r.id, c.project) : null, fire: false, keep: true, item: c });
}
}
for (const a of all) a.state = AGENT_STATE_KEY[a.dot[2]] || 'not-running';
return all;
}
async function agentsPage(q, opts = {}) {
// SP5 review F11: a scope that is not an organization id is refused, never widened to the system list.
if (opts.scope != null && !(typeof opts.scope === 'string' && ORG_ID.test(opts.scope))) return '
Agents
That is not an organization address.
';
const scope = opts.scope ?? null;
const org = scope ? [scope] : listParam(q, 'org', id => ORG_ID.test(id));
const want = String(q?.get?.('state') || '');
const stateF = AGENT_STATE.some(([k]) => k === want) ? want : null;
// SP12: the system page's agent drawer reads beside the page.
// SP13: it waits on its own instances read only until this page's reads have answered.
let pageRead = () => {}; const page = new Promise(done => { pageRead = done; });
const drawerRead = scope ? Promise.resolve('') : agentDrawer(q, { configIn: opts.configIn, page }).catch(() => '');
let body;
try { [body] = await Promise.all([data.workspace({ sections: ['sessions', 'projects'] }), ensureThemes()]); took(body); }
catch (err) { return failedPage('ws-agents-all', 'data-ws-agents', 'Agents', err); }
const every = orgsOf(body);
const o = org ? { ...every, rows: every.rows.filter(r => org.includes(r.org)), unread: every.unread.filter(r => org.includes(r.org)) } : every;
const askable = (scope ? o.rows : every.rows).filter(r => r.state === 'ok');
// Each answering organization's instances, and (system page only) whether this Console decides there.
const reads = await readInstances(askable.map(r => r.org), scope ? null : opts.fireIn);
pageRead();
const all = agentRows(reads, body);
const counts = new Map();
for (const a of all) counts.set(a.org, (counts.get(a.org) || 0) + 1);
const inOrg = all.filter(a => !org || org.includes(a.org)).sort((x, y) => x.org.localeCompare(y.org) || x.name.localeCompare(y.name) || x.key.localeCompare(y.key));
const filteredRows = inOrg.filter(a => !stateF || a.state === stateF);
// SP5 review F1/F2: Open addresses one agent (`#/orgs//agents?agent=`). The scoped page puts
// that agent first and marks it, and draws no Open of its own, which would only link to itself.
const picked = scope ? String(q?.get?.('agent') || '') : '';
const hit = picked ? filteredRows.find(a => a.key === picked) || null : null;
const rows = hit ? [hit, ...filteredRows.filter(a => a !== hit)] : filteredRows;
const akey = a => `${a.org}:${a.key}`;
const orgChip = a => `${esc(o.name(a.org))}`;
const projOf = a => a.project || a.s?.project || null;
const projChip = a => (projOf(a)?.name ? `${esc(projOf(a).name)}` : '');
const work = a => (a.s?.task ? `${esc(a.s.task.title || a.s.task.ref)}${a.s.task.title && a.s.task.ref ? `${esc(a.s.task.ref)}` : ''}` : 'nothing reported');
const LEVEL_WORD = { root: 'root agent copy', project: 'project agent' };
const row = a => `
`;
// An organization that did not answer is named first, with the reason its read gave; one that
// answered but whose instances read failed is named too, never counted as having no agents.
const why = r => `${stateWords(r).replace(/, read .*$/, '')}${r.reason ? `: ${esc(r.reason)}` : ''}${r.at ? ` (read ${esc(hm(r.at))})` : ''}`;
const failed = reads.filter(r => !r.inst && (!org || org.includes(r.id)));
const unread = (o.unread.length ? `
Not read: ${andList(o.unread.map(why))}.
` : '')
+ (failed.length ? `
Agents not read in ${andList(failed.map(r => `${esc(o.name(r.id))} (${esc(instWhy(r))})`))}.
` : '')
+ missLine(o, ['agents', 'tasks'], 'agents', 'What agents work on was not read in');
const anyRead = reads.some(r => r.inst && (!org || org.includes(r.id)));
const filtered = (org && !scope) || stateF;
const table = rows.length
? `
Agents
Agent
Role
State
Working on
${scope ? '' : '
Actions
'}
${rows.map(row).join('')}
`
: `
${!anyRead && o.rows.length ? 'Agents not read' : filtered ? 'Nothing matches these filters' : 'No agents'}
`;
const stateCounts = new Map();
for (const a of inOrg) stateCounts.set(a.state, (stateCounts.get(a.state) || 0) + 1);
const shown = AGENT_STATE.filter(([k]) => stateCounts.has(k) || k === stateF);
const stateChips = `
State${shown.map(([k, w]) => ``).join('')}
`;
// The org chips count each answering organization's agents; an organization whose instances read
// failed shows "not read", as one that did not answer shows its state.
const notRead = new Set(reads.filter(r => !r.inst).map(r => r.id));
const chipOrgs = { ...every, rows: every.rows.map(r => (notRead.has(r.org) ? { ...r, errors: { ...(r.errors || {}), instances: 'not read' } } : r)) };
const orgsWith = new Set(rows.map(a => a.org)).size;
// SP11: running and working in the Dashboard tiles' words, over the rows shown.
const tally = rows.length ? ` ${plural(rows.length, 'agent')}${scope ? '' : ` in ${plural(orgsWith, 'organization')}`}: ${runningOf(rows)} running, ${workingOf(rows)} working.` : '';
const sub = scope
? `Agents in ${esc(o.name(scope))} only.${tally} Every organization`
: `Every agent on the system, by organization.${tally} Open one to see it in its organization.`;
return `
`}
${await drawerRead}
`;
}
// ---- the agent drawer (#1873 SP12) ----
// `?agent=:` on #/agents or an organization page opens one agent's details at the right of
// the page; the page stays under it. Every field comes from a read the Console already makes: the
// workspace read scoped to the agent's organization (its session, project, task, open tasks and the
// decisions it raised), that organization's instances read (role, source, state) and its business
// read (model). A field no read gives is left out. Actions follow the organization's own config:
// Message where it sends chat there, Stop (one agent, /agent/terminate) where it changes agents.
const agentPick = q => {
const v = String(q?.get?.('agent') || ''), cut = v.indexOf(':');
if (cut < 1) return null;
const org = v.slice(0, cut), key = v.slice(cut + 1);
return ORG_ID.test(org) && key && key.length <= 200 && !/\s/.test(key) ? { org, key, id: v } : null;
};
const DRAWER_LIMIT = 5, STOP_REASON = 'Stopped from the agent drawer.';
const STOP_UNKNOWN = 'Outcome unknown. Read the agents again before trying; nothing was retried.';
// SP20: an organization that refuses a Stop or a Restart, in the same line for both.
const orgRefusal = (e, orgName) => e === 'org-archived' ? `${orgName} is archived, so its agents are not changed. Nothing changed.`
: e === 'org-unavailable' ? `${orgName} is not available to this Console. Nothing changed.` : '';
// Each drawer agent's question and Stop survive repaints: `confirm` while it asks, `busy` while the
// request is open, then the result in words beside the button. SP19: `kind` says whether Stop or
// Restart asks (no kind is Stop). While either asks or runs, both buttons wait. SP20: kept per agent,
// as restarts are, so two Stops in two drawers each keep their line. An entry goes when the drawer
// closes after it finished, when its question is cancelled, or when its Restart starts.
const stops = new Map(); // id -> { kind, confirm, busy, text }
// SP19: each drawer agent's restart, kept per agent so several can run at once and none loses its
// line when another drawer asks or stops: `busy` while it runs, then its outcome in words. An entry
// goes when a new question starts on that agent, or when the drawer closes after it finished.
const restarts = new Map(); // id -> { busy, text }
// The state a drawer draws: its own question or Stop first, else its restart.
const actState = id => stops.has(id) ? { id, ...stops.get(id) } : restarts.has(id) ? { id, kind: 'restart', ...restarts.get(id) } : null;
const RESTART_REASON = 'restart from the agent drawer';
let drawerFocus = false, drawerShown = null;
// The drawer holds at most one history entry. A row opened from the page without a drawer pushes one
// entry marked in history.state; switching rows replaces it. Close goes Back only from that marked
// entry, so a shared link or a reload of an unmarked one never leaves the Console.
const DRAWER_MARK = 'mosaicAgentDrawer';
const stateOf = () => (history.state && typeof history.state === 'object' ? history.state : null);
const unmarked = () => { const st = stateOf(); if (!st || !(DRAWER_MARK in st)) return history.state; const { [DRAWER_MARK]: _, ...rest } = st; return rest; };
const drawerHref = (q, id) => { const n = new URLSearchParams(q?.toString?.() || ''); n.set('agent', id); return `#${pathOf()}?${n.toString()}`; };
// The address of the page under the drawer: the organization prefix and path, the query without `agent`.
const sansAgent = () => { const n = queryOf(); n.delete('agent'); const s = n.toString(); return `${/^#\/orgs\/[^/?]+/.exec(location.hash)?.[0] ?? '#'}${pathOf()}${s ? `?${s}` : ''}`; };
// The row's name as a link that opens the drawer: a native link, so Tab reaches it and Enter opens it.
const drawerLink = (q, a) => `${esc(a.name)}`;
// SP19: Stop and Restart ask in the same confirm step, each under its own data attributes.
const actConfirm = (kind, name, question) => `${esc(question)} `;
const stopConfirm = (name, who) => actConfirm('stop', name, `Stop ${who}?`);
const restartConfirm = (name, who, thread) => actConfirm('restart', name, `Restart ${who}? ${thread ? 'It ends its session; its next message starts it again.' : 'It ends its session and launches it again.'}`);
function stopActions(pick, a, orgName, thread) {
const st = actState(pick.id), kind = st?.kind || 'stop';
const who = `${a.name} in ${orgName}`, hold = st?.busy || st?.confirm ? ' disabled' : '';
const stop = `${st?.confirm && kind === 'stop' ? stopConfirm(a.name, who) : ''}`;
if (!window.MosaicAgents?.restart) return stop;
return `${stop} ${st?.confirm && kind === 'restart' ? restartConfirm(a.name, who, thread) : ''}`;
}
// SP13 (#1873): the drawer's instances read gives the agent's state. The drawer does not hold the
// page for it: once the page's own reads have answered (`opts.page`), a drawer whose instances read
// has not says its state is being read, and repaints when the read answers. A repaint while the read
// is still open waits on the same read; once it answers it is let go, so the next render reads again.
let drawerInst = null, drawerReads = 0; // { org, n, done, value, p }
// Repaints whose read answered before their drawer was on screen, keyed by the drawer's
// data-drawer-pending and its agent id. A drawer never painted (closed, or replaced by a later paint)
// leaves its entry; the oldest go first.
const drawerLate = new Map(), DRAWER_LATE_MAX = 8;
const drawerInstRead = org => {
if (drawerInst?.org === org) return drawerInst;
const r = { org, n: ++drawerReads, done: false, value: null };
r.p = data.instances(org).then(v => ({ inst: instancesOf(v), copies: copiesOf(v) }), err => ({ inst: null, copies: {}, err }))
.then(v => { r.done = true; r.value = v; return v; });
r.p.then(() => { if (drawerInst === r) drawerInst = null; });
drawerInst = r;
return r;
};
// SP16 (#1873): the template a pack hire was hired from. Only the packs read names it (owner only):
// the pack's hire of this name points at a definition, and that definition at a template. It is read
// only for an organization agent the instances read says a pack hired. The answer is kept per
// organization for DRAWER_PACKS_KEEP ms, and a repaint draws from the kept answer, also while a newer
// read is open, so the line does not change on every poll and a poll does not read packs each time.
// A kept answer that is of no use for this hire is read again at once (SP16 review 3): a refusal or no
// answer on each render, so the line recovers with the route; an answer that does not name this hire
// (a hire made after it was read) once per hire until the keep runs out, so a hire the pack really
// does not name does not read packs on every poll. `p` is given only when the drawer should repaint
// on it: nothing is kept, or the kept answer is of no use for this hire. `value` is then the kept
// refusal, or nothing (the line says being read) rather than a kept answer that does not name it.
// `start` false only looks: the drawer's second look after its race starts no read.
// The pack is the one installed now; the read does not say which version the hire was made from.
// It never rejects: a refusal, no answer or an answer that is not the packs list each give `err`.
const drawerPacksKept = new Map(), DRAWER_PACKS_KEEP = 60000; // org -> { at, value, p, asked }
const drawerPacks = (org, instValue, key, start = true) => {
const item = instValue?.inst?.[key];
if (!item || !isHired(item) || typeof item.pack?.id !== 'string') return null;
let k = drawerPacksKept.get(org);
if (!k) drawerPacksKept.set(org, (k = { at: 0, value: null, p: null, asked: new Set() }));
const v = k.value, named = !!v && !v.err && !!packTemplate(item, key, v).template;
const expired = !v || Date.now() - k.at >= DRAWER_PACKS_KEEP;
const again = !!v && (!!v.err || (!named && !k.asked.has(key)));
if (start && !k.p && (expired || again)) {
if (expired) k.asked.clear();
if (v && !v.err && !named) k.asked.add(key);
const kept = k;
kept.p = fetch(`/api/orgs/${enc(org)}/packs`, { cache: 'no-store', redirect: 'manual' }).then(async r => {
if (!r.ok || r.type === 'opaqueredirect') return { err: { status: r.type === 'opaqueredirect' ? 0 : r.status } };
const v = await r.json().catch(() => null);
return Array.isArray(v?.packs) ? { packs: v.packs } : { err: { code: 'no answer' } };
}).catch(() => ({ err: { code: 'no answer' } })).then(v => { kept.value = v; kept.at = Date.now(); kept.p = null; return v; });
}
const wait = k.p && !named ? k.p : null;
return { value: wait && v && !v.err ? null : v, p: wait };
};
// The pack's own label and the template its hire of this name is made from, from the packs read. The
// instance names only the pack's id; the installed pack's document carries its label.
const packTemplate = (item, name, read) => {
const pk = item?.pack, doc = arr(read?.packs).find(p => p?.id === pk?.id && (pk?.origin == null || p?.origin === pk.origin))?.pack;
const hire = arr(doc?.hires).find(h => h?.name === name);
const entry = typeof hire?.definition === 'string' && doc?.definitions && typeof doc.definitions === 'object' ? doc.definitions[hire.definition] : null;
const t = entry?.template ?? entry?.from?.template;
return { template: typeof t === 'string' && t ? t : '', label: typeof doc?.label === 'string' && doc.label ? doc.label : '' };
};
// Swaps a drawer still on screen for `html`, keeping focus, and runs at once a repaint already waiting
// on the fresh drawer's marker (its packs read answered before this drawer was painted).
const drawerSwap = (node, html) => {
const key = focusKey(node), tpl = document.createElement('template');
tpl.innerHTML = html;
const fresh = tpl.content.firstElementChild;
if (!fresh) return;
node.replaceWith(fresh);
refocus(fresh, key);
drawerLateRun(fresh);
};
function drawerLateRun(node) {
const k = `${node.dataset.drawerPending}:${node.dataset.wsDrawer}`, redo = node.dataset.drawerPending ? drawerLate.get(k) : null;
if (redo) { drawerLate.delete(k); redo(node); }
}
// Repaints the drawer that carries `mark` once `p` answers: now if it is on screen, else once it is
// painted. `build(answer)` runs when the read answers and gives what draws the drawer at the swap.
const drawerWhen = (p, mark, id, build) => p.then(v => {
const draw = build(v), redo = node => drawerSwap(node, draw());
const node = document.querySelector(`#bus-view [data-ws-drawer="${CSS.escape(id)}"][data-drawer-pending="${mark}"]`);
if (node) { redo(node); return; }
drawerLate.set(`${mark}:${id}`, redo);
while (drawerLate.size > DRAWER_LATE_MAX) drawerLate.delete(drawerLate.keys().next().value);
});
async function agentDrawer(q, opts = {}) {
const pick = agentPick(q);
if (!pick || (opts.only && pick.org !== opts.only)) return '';
const { org, id } = pick;
const ir = drawerInstRead(org);
const [body, business, config] = await Promise.all([
data.workspace({ org, sections: ['sessions', 'projects', 'inbox', 'tasks'] }).catch(() => null),
data.business(org).catch(() => null),
typeof opts.configIn === 'function' ? Promise.resolve(opts.configIn(org)).catch(() => null) : null,
ensureThemes(),
]);
const page = opts.page ?? null;
const html = (instRead, packs, pending) => drawerHtml(pick, { body, business, config, pending, instRead, packs });
// Each read the drawer waits on is raced against the page's reads (SP16 review), so neither the
// instances read nor a pack hire's packs read holds the page's paint.
await Promise.race([ir.p, page ?? ir.p]);
// SP14 (#1873): when a read answers, only the drawer repaints, from the reads it already has; the
// page's own reads are not made again. data-drawer-pending names the read it waits on: `` for the
// instances read, `p` for the packs read after it, so each repaint finds only its own drawer. A
// closed drawer repaints nothing. SP16: a read can answer after this HTML is returned and before the
// page that carries it is on screen; then the repaint waits in drawerLate, and afterPaint runs it.
// When the instances read answers, the state is drawn at once, and the template line, if its packs
// read is still open with nothing of use kept, says it is being read (or the kept refusal) and
// repaints when that read answers.
const packsStage = instRead => {
const pk = drawerPacks(org, instRead, pick.key);
if (pk?.p) drawerWhen(pk.p, `${ir.n}p`, id, v => () => html(instRead, v, false));
return { packs: pk?.value ?? null, pending: pk?.p ? `${ir.n}p` : false };
};
if (!ir.done) {
drawerWhen(ir.p, ir.n, id, v => { const s = packsStage(v); return () => html(v, s.packs, s.pending); });
return html(null, null, ir.n);
}
let pk = drawerPacks(org, ir.value, pick.key);
if (pk?.p) {
await Promise.race([pk.p, page ?? pk.p]);
pk = drawerPacks(org, ir.value, pick.key, false);
}
if (pk?.p) {
drawerWhen(pk.p, `${ir.n}p`, id, v => () => html(ir.value, v, false));
return html(ir.value, pk.value, `${ir.n}p`);
}
return html(ir.value, pk?.value ?? null, false);
}
function drawerHtml(pick, { body, business, config, pending, instRead, packs = null }) {
const { org, key, id } = pick;
const o = orgsOf(body), orgName = o.name(org);
const close = ``;
const shell = (title, inner, attrs = '') => ``;
// While the instances read is open, or after it failed, the agent's name is the address's and its
// role, source and state are not known: the state says so, and Stop gives that as its reason. A drawer
// can be pending with its instances read answered, while a pack hire's packs read is still open.
const reading = pending && !instRead;
const unknown = reading ? 'Reading state…' : !instRead?.inst ? `State not read: ${esc(instWhy(instRead || {}))}.` : '';
const a = unknown ? { org, key, name: key, level: 'org', keep: false, item: {}, s: arr(body?.sessions).find(x => x?.kind === 'role' && x.org === org && x.role === key) || null }
: agentRows([{ id: org, inst: instRead.inst, copies: instRead.copies }], body).find(r => r.key === key);
if (!a) return shell(key, `
No agent named ${esc(key)} was read in ${esc(orgName)}.
';
// Actions, only where this organization's config says this Console writes there.
const chat = config?.chatSend === true && config?.tester !== true, change = config?.settingsSend === true && config?.tester !== true;
const acts = [];
if (chat && thread?.thread) acts.push(`Message ${esc(a.name)}`);
else if (chat && a.level === 'org' && window.MosaicAgents?.isThread?.(def)) acts.push(`Message ${esc(a.name)}Start one from New thread in ${esc(orgName)}.`);
// SP16: where no Message is offered, one line says why. The Console opens a conversation only in an
// Assistant pane, with a conversation agent; a role agent takes messages on the bus, which an
// organizations Console does not send.
else if (chat) acts.push(`
${reading ? 'No Message: its state is being read, so it is not known whether it holds a conversation.'
: unknown ? `No Message: its state was not read (${esc(instWhy(instRead || {}))}), so it is not known whether it holds a conversation.`
: a.level !== 'org' ? 'No Message: a copy is not messaged from here.'
: 'No Message: this Console messages only conversation agents, such as the Assistant.'}
`);
else if (change) acts.push(`
No Message: this Console does not send chat in ${esc(orgName)}.
`);
// SP19: a restart that is running keeps its buttons even when a repaint reads no run between its end and its launch.
if (change && a.level === 'org' && !a.keep && (running(item) > 0 || restarts.get(id)?.busy)) acts.push(stopActions(pick, a, orgName, !!window.MosaicAgents?.isThread?.(def)));
// Why Stop is not offered, in words, where this Console could otherwise change the organization's agents.
// SP13: "not running" is a reason only once the instances read has given the agent's runs.
else if (change) acts.push(`
${reading ? 'Its state is being read. Stop is offered once it is read and the agent is running.'
: unknown || !runsRead(item) ? 'Its state was not read, so Stop is not offered.'
: a.level !== 'org' ? 'A copy is not stopped from here.'
: a.keep ? `${esc(a.name)} is one of ${esc(orgName)}’s protected agents, so it is not stopped from here.`
: 'It is not running, so there is nothing to stop.'}
This Console only reads ${esc(orgName)}. It can not message or stop its agents.
`;
// SP18: the agents read lists only roles a run holds now, and thread.claims only conversations a run
// holds now; each row carries that run and when it took the role or the conversation. A claim counts
// only when the instances read lists its run as running, so a claim left by a run that ended does not
// date a stopped agent. Last activity is the latest such time. No read keeps when a run ended or when
// the agent last sent a message (a thread's messages read pages from the oldest message), so neither is shown.
const runs = !unknown && runsRead(item) ? item.running : null;
const claims = [a.s ? { ...a.s, what: 'the role' } : null, ...arr(body?.sessions).filter(x => x?.kind === 'thread' && x.org === org && x.instance === key).map(x => ({ ...x, what: 'the conversation' }))]
.filter(c => c && msOf(c.claimedAt) !== null && (!runs || runs.includes(c.run))).sort((x, y) => msOf(y.claimedAt) - msOf(x.claimedAt));
const last = claims[0], claimWhy = notRead(['agents', 'claims']);
// With the runs not read, nothing checked the claim against a live run, so the line says "a run".
const activity = last ? `${!runs ? 'a run' : runs.length > 1 ? `one of its ${runs.length} runs` : 'its run'} took ${last.what} `
: `${claimWhy ? `not read: ${esc(claimWhy)}`
: runs?.length ? `not recorded: ${runs.length > 1 ? 'its runs hold' : 'its run holds'} no role or conversation yet`
: !runs ? 'not recorded: the agents and claims reads show no run holding its role or a conversation, and its runs were not read'
: 'not recorded: no run holds it now, and no read keeps when its last run ended'}`;
const fields = [
field('org', 'Organization', orgChip(o, org)),
// A pack hire's pack is named once, in Hired from; the Role row says only that it was hired.
unknown ? '' : field('role', 'Role', `${esc(hiredFrom && packOf(item) ? 'Hired' : a.role)}`),
unknown ? '' : field('source', 'Source', source),
hiredFrom ? field('hired', 'Hired from', hiredFrom) : '',
field('state', 'State', unknown ? `${unknown}` : dot(...a.dot, true)),
model ? field('model', 'Model', `${esc(model)}`) : '',
project ? field('project', 'Project', `${esc(project.name || project.key || project.id)}${project.from ? ` ${project.from}` : ''}`) : '',
task ? field('task', 'Task', `${esc(task.title || task.ref)}${task.title ? ` ${esc(task.ref)}` : ''}`) : '',
field('activity', 'Last activity', activity),
].join('');
return shell(a.name, `
${fields}
Open tasks
${tasksBody}${tasksAll}
Decisions waiting on you
${decBody}
${actions}`, ` data-drawer-org-id="${esc(org)}" data-drawer-name="${esc(a.name)}" data-drawer-org-name="${esc(orgName)}"${pending ? ` data-drawer-pending="${pending}"` : ''}`);
}
// Closing goes Back when a row link on this page pushed the current entry; otherwise it drops
// `agent` from the address in place. Either way the page repaints without it and focus returns to the row.
function closeDrawer() {
for (const [k, st] of stops) if (!st.busy) stops.delete(k);
for (const [k, r] of restarts) if (!r.busy) restarts.delete(k);
if (stateOf()?.[DRAWER_MARK] && queryOf().has('agent')) { history.back(); return; }
history.replaceState(unmarked(), '', sansAgent());
document.dispatchEvent(new CustomEvent('mosaic-workspace-render'));
}
// SP18: below 701 px the open drawer is a sheet and shell.css holds the page under it to one screen, which
// scrolls the page to the top. The page's place is kept while no drawer is open, with the page the sheet
// opened over. It is put back only when the drawer closes onto that same page (Close, Escape or Back); a
// link in the sheet goes to another page, which starts at its top, and the kept place is dropped. Some
// pages a link opens (a project, the Assistant) are drawn without afterPaint, so the place is dropped as
// soon as the address leaves the page under the sheet.
const SHEET = window.matchMedia('(max-width:700px)');
let pageY = 0, sheetOver = null;
window.addEventListener('scroll', () => { if (!document.querySelector('#bus-view [data-ws-drawer]')) pageY = window.scrollY; }, { passive: true });
window.addEventListener('hashchange', () => { if (sheetOver !== null && sansAgent() !== sheetOver) { sheetOver = null; pageY = 0; } });
// bus.js calls this after each paint: focus moves into a drawer a row opened, and back to the row
// when the drawer has closed and focus was left nowhere.
function afterPaint() {
for (const node of document.querySelectorAll('#bus-view [data-ws-drawer][data-drawer-pending]')) drawerLateRun(node);
const view = document.getElementById('bus-view'), d = view?.querySelector('[data-ws-drawer]');
const now = d?.dataset.wsDrawer || null, was = drawerShown;
drawerShown = now;
if (now) sheetOver = sansAgent();
if (d && drawerFocus) { drawerFocus = false; d.querySelector('h2')?.focus({ preventScroll: true }); return; }
drawerFocus = false;
if (!now && sheetOver !== null) {
if (SHEET.matches && pageY && sheetOver === sansAgent()) window.scrollTo(0, pageY);
sheetOver = null; pageY = window.scrollY;
}
if (!now && was) {
const a = document.activeElement;
if (!a || a === document.body || !view?.contains(a)) view?.querySelector(`[data-focus-key="${CSS.escape(`agent:${was}`)}"]`)?.focus({ preventScroll: true });
}
}
async function stopAgent(d) {
const id = d.dataset.wsDrawer, org = d.dataset.drawerOrgId, name = id.slice(org.length + 1), orgName = d.dataset.drawerOrgName;
stops.set(id, { busy: true, text: `Stopping ${name}…` });
const repaint = () => document.dispatchEvent(new CustomEvent('mosaic-workspace-render'));
// Paint this agent's drawer in place, when it is on screen.
const paint = () => { const now = document.querySelector(`[data-ws-drawer="${CSS.escape(id)}"]`), st = stops.get(id); if (!now || !st) return; const s = now.querySelector('[data-drawer-status]'); if (s) s.textContent = st.text; const b = now.querySelector('[data-drawer-stop]'); if (b) { b.disabled = !!st.busy; b.firstChild.textContent = st.busy ? 'Stopping…' : 'Stop'; } const rb = now.querySelector('[data-drawer-restart]'); if (rb) rb.disabled = !!st.busy; now.querySelector('[data-drawer-stop-confirm]')?.remove(); };
const finish = text => { stops.set(id, { text }); paint(); const b = document.querySelector(`[data-ws-drawer="${CSS.escape(id)}"] [data-drawer-stop]`); b?.focus({ preventScroll: true }); };
paint();
let res, body = null;
try { res = await fetch(`/api/orgs/${enc(org)}/agent/terminate`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ instance: name, reason: STOP_REASON }), cache: 'no-store', redirect: 'manual' }); }
catch { return finish(`Not stopped: ${STOP_UNKNOWN}`); }
if (res.type === 'opaqueredirect' || res.status === 401) return finish('Not stopped: sign in again, then read the agents.');
try { body = await res.json(); } catch { body = null; }
if (!res.ok || body?.sent !== true && !body?.request) {
const orgWhy = orgRefusal(body?.error, orgName);
if (orgWhy) return finish(`Not stopped: ${orgWhy}`);
if (body?.sent === false && typeof body.message === 'string' && body.message) return finish(`Not stopped: ${body.message}`);
if (res.status === 403 && body?.error === 'read-only') return finish(`Not stopped: this Console only reads agents in ${orgName} (read-only).`);
if (body?.sent === false && typeof body.error === 'string') return finish(`Not stopped: the bus refused (${body.error}).`);
return finish(`Not stopped: ${STOP_UNKNOWN}`);
}
const request = typeof body?.request === 'string' ? body.request : '';
if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(request)) return finish(STOP_UNKNOWN);
stops.set(id, { busy: true, text: `Stop asked: request ${request} is open.` }); paint();
for (let tries = 0; tries < 90; tries++) {
await new Promise(r => setTimeout(r, 2000));
let r = null;
try { const got = await fetch(`/api/orgs/${enc(org)}/agent/request?id=${enc(request)}`, { cache: 'no-store', redirect: 'manual' }); if (got.type === 'opaqueredirect') return finish('Sign in again, then read the agents.'); r = got.ok ? await got.json() : null; } catch { continue; }
if (r?.request === request && r.state === 'closed') {
if (r.reason) return finish(`Not stopped: ${r.reason}.`);
stops.set(id, { text: `Stopped ${name}.` }); repaint(); return;
}
}
finish(`Request ${request} is still open. Read the agents again later.`);
}
// SP19: the drawer's Restart. The agents.js chain ends the agent through its own organization's routes
// (the drawer's, which on #/agents is not the page's), waits for the request to close and its runs to
// reach 0, then launches it; a conversation agent is not launched. It never regenerates. Each step is
// painted in place; a refusal before the end leaves both buttons usable and focus on Restart.
const refusedWhy = (d, orgName) => {
const e = d?.result?.error, m = d?.result?.message;
if (d?.status === 403 && e === 'read-only') return `this Console only reads agents in ${orgName} (read-only).`;
if (d?.status === 403 && (e === 'unavailable' || e === 'owner-only')) return `this Console is not the owner of ${orgName}, so it does not restart its agents.`;
if (e === 'no-bus-host') return `the bus of ${orgName} is not running. Nothing changed.`;
const orgWhy = orgRefusal(e, orgName);
if (orgWhy) return orgWhy;
if (d?.result?.sent === false && typeof m === 'string' && m) return m;
if (d?.result?.sent === false && typeof e === 'string') return `the bus refused (${e}).`;
return STOP_UNKNOWN;
};
const restartWords = (name, orgName) => (step, d) => ({
ending: `Restarting ${name}: asking it to end…`,
signedOut: 'Not restarted: sign in again, then read the agents.',
endUnknown: `Not restarted: ${STOP_UNKNOWN}`,
endRefused: `Not restarted: ${refusedWhy(d, orgName)}`,
endOpen: `Not restarted: ${d?.stop}`,
endClosed: `Not restarted: ${name} was not ended (${d?.reason}).`,
ended: `${name} was asked to end. Waiting for its session to end…`,
stillRunning: `Not restarted: ${name} was asked to end, but its session is still running. Read the agents again before trying.`,
threadEnded: `Ended ${name} at ${d?.time}. Its next message starts it.`,
launching: `${name} has ended. Launching it…`,
launchSignedOut: `${name} was ended and not launched: sign in again, then read the agents.`,
launchUnknown: `${name} was ended. The launch outcome is unknown; read the agents again before trying. Nothing was retried.`,
launchRefused: `${name} was ended and not launched: ${refusedWhy(d, orgName)}`,
launchOpen: `${name} was ended. ${d?.stop}`,
launchClosed: `${name} was ended and not launched: ${d?.reason}.`,
restarted: `Restarted ${name}${d?.run ? ` (run ${d.run})` : ''}.`,
})[step];
async function restartAgent(d) {
const id = d.dataset.wsDrawer, org = d.dataset.drawerOrgId, name = id.slice(org.length + 1), orgName = d.dataset.drawerOrgName;
const thread = d.querySelector('[data-drawer-restart]')?.dataset.drawerThread === 'yes';
if (restarts.get(id)?.busy) return;
// The question is answered: from now on this agent's drawer draws its restart.
stops.delete(id);
restarts.set(id, { busy: true, text: '' });
// Paint this agent's drawer in place, when it is on screen and no question of its own holds it.
const paint = () => {
const now = document.querySelector(`[data-ws-drawer="${CSS.escape(id)}"]`), r = restarts.get(id); if (!now || !r || stops.has(id)) return;
const s = now.querySelector('[data-drawer-status]'); if (s) s.textContent = r.text;
const rb = now.querySelector('[data-drawer-restart]'), sb = now.querySelector('[data-drawer-stop]');
if (rb) { rb.disabled = r.busy; rb.firstChild.textContent = r.busy ? 'Restarting…' : 'Restart'; }
if (sb) sb.disabled = r.busy;
now.querySelector('.ws-drawer-confirm')?.remove();
};
// The finished line stays in the entry. A refusal before the end changed nothing, so focus goes back
// to Restart. Once the agent was ended its runs changed: the repaint reads the instances again, so the
// buttons follow them (after a refused launch it has none, so Stop and Restart go), and focus goes to
// the drawer's heading, which every repaint keeps.
const after = new Set(['restarted', 'threadEnded', 'launchSignedOut', 'launchUnknown', 'launchRefused', 'launchOpen', 'launchClosed']);
const done = step => {
document.querySelector(`[data-ws-drawer="${CSS.escape(id)}"]`)?.querySelector(after.has(step) ? '[data-focus-key="drawer-h"]' : '[data-drawer-restart]')?.focus({ preventScroll: true });
if (after.has(step)) document.dispatchEvent(new CustomEvent('mosaic-workspace-render'));
};
const onStatus = ({ step, busy, text }) => {
restarts.set(id, { busy: !!busy, text });
paint();
if (!busy) done(step);
};
try { await window.MosaicAgents.restart(name, thread, { org, reason: RESTART_REASON, text: restartWords(name, orgName), onStatus }); }
catch { restarts.set(id, { busy: false, text: `Not restarted: ${STOP_UNKNOWN}` }); paint(); done('endUnknown'); }
}
document.addEventListener('click', e => {
const link = e.target.closest?.('[data-ws-drawer-open]');
if (link) {
if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0) return;
e.preventDefault();
const to = new URL(link.href).hash;
// The open row again: the address stays, focus goes to the drawer's heading.
if (to === location.hash) { document.querySelector('#bus-view [data-ws-drawer] h2')?.focus({ preventScroll: true }); return; }
drawerFocus = true;
if (queryOf().has('agent')) history.replaceState(history.state, '', to);
else history.pushState({ ...(stateOf() || {}), [DRAWER_MARK]: true }, '', to);
document.dispatchEvent(new CustomEvent('mosaic-workspace-render'));
return;
}
const d = e.target.closest?.('[data-ws-drawer]');
if (!d) return;
if (e.target.closest('[data-drawer-close]')) { closeDrawer(); return; }
const id = d.dataset.wsDrawer;
// SP19: nothing starts while this agent's Stop or Restart runs.
const held = !!stops.get(id)?.busy || !!restarts.get(id)?.busy;
const ask = e.target.closest('[data-drawer-stop]') ? 'stop' : e.target.closest('[data-drawer-restart]') ? 'restart' : null;
if (ask && !held) {
const b = d.querySelector(`[data-drawer-${ask}]`), name = d.dataset.drawerName, who = `${name} in ${d.dataset.drawerOrgName}`;
stops.set(id, { kind: ask, confirm: true, text: '' }); restarts.delete(id);
d.querySelector('.ws-drawer-confirm')?.remove();
b.insertAdjacentHTML('afterend', ask === 'stop' ? stopConfirm(name, who) : restartConfirm(name, who, b.dataset.drawerThread === 'yes'));
for (const x of d.querySelectorAll('[data-drawer-stop], [data-drawer-restart]')) x.disabled = true;
const s = d.querySelector('[data-drawer-status]'); if (s) s.textContent = '';
d.querySelector(`[data-drawer-${ask}-no]`)?.focus({ preventScroll: true });
return;
}
if (ask) return;
if (e.target.closest('[data-drawer-stop-no], [data-drawer-restart-no]')) { cancelStop(d); return; }
if (held) return;
if (e.target.closest('[data-drawer-stop-yes]')) stopAgent(d);
else if (e.target.closest('[data-drawer-restart-yes]')) restartAgent(d);
});
// Cancel the Stop or Restart question: nothing sent, both buttons enabled again, focus on the one that asked.
function cancelStop(d) {
const kind = d.querySelector('[data-drawer-restart-confirm]') ? 'restart' : 'stop';
stops.delete(d.dataset.wsDrawer);
d.querySelector('.ws-drawer-confirm')?.remove();
for (const x of d.querySelectorAll('[data-drawer-stop], [data-drawer-restart]')) x.disabled = false;
d.querySelector(`[data-drawer-${kind}]`)?.focus({ preventScroll: true });
}
// Escape cancels the Stop or Restart question while it asks, else closes the drawer, unless a dialog is open
// or something else took the key.
document.addEventListener('keydown', e => {
if (e.key !== 'Escape' || e.defaultPrevented || document.querySelector('dialog[open]')) return;
const d = document.querySelector('#bus-view [data-ws-drawer]');
if (!d) return;
e.preventDefault();
if (d.querySelector('.ws-drawer-confirm')) cancelStop(d); else closeDrawer();
});
// ---- controls: filters write the hash query and repaint in place ----
const pathOf = () => route().split('?')[0];
const queryOf = () => new URLSearchParams(route().split('?')[1] || '');
function setQuery(change, render = true) {
const q = queryOf();
for (const [k, v] of Object.entries(change)) { if (v === null || v === undefined || v === '' || (Array.isArray(v) && !v.length)) q.delete(k); else q.set(k, Array.isArray(v) ? v.join(',') : String(v)); }
const s = q.toString();
// SP3: the address keeps its own form, an organization's or the system's (#/inbox).
// A filter change makes the entry differ from the one before the drawer, so Close then stays in place.
history.replaceState(unmarked(), '', `${/^#\/orgs\/[^/?]+/.exec(location.hash)?.[0] ?? '#'}${pathOf()}${s ? `?${s}` : ''}`);
if (render) document.dispatchEvent(new CustomEvent('mosaic-workspace-render'));
}
function setGrouping(g) {
grouping = g === 'flat' ? 'flat' : 'org'; save(GROUPING, grouping); paint();
if (pathOf() === '/projects') document.dispatchEvent(new CustomEvent('mosaic-workspace-render'));
}
document.addEventListener('click', e => {
const page = e.target.closest?.('[data-ws-projects],[data-ws-inbox],[data-ws-agents]');
if (!page) return;
const st = e.target.closest('[data-ws-astate]');
if (st) { setQuery({ state: st.dataset.wsAstate || null }); return; }
const chip = e.target.closest('[data-ws-org]');
if (chip) {
const id = chip.dataset.wsOrg, now = listParam(queryOf(), 'org', x => ORG_ID.test(x)) || [];
const next = !id ? [] : now.includes(id) ? now.filter(x => x !== id) : [...now, id];
setQuery(page.hasAttribute('data-ws-inbox') ? { org: next, d: null } : { org: next });
return;
}
const sort = e.target.closest('[data-ws-sort]');
if (sort) {
const f = projectQuery(queryOf()), s = sort.dataset.wsSort;
setQuery(s === f.sort ? { sort: s, order: f.order === 'desc' ? 'asc' : 'desc' } : { sort: s, order: null });
return;
}
const kind = e.target.closest('[data-ws-type]');
if (kind) { setQuery({ type: kind.dataset.wsType || null, d: null }); return; }
const grp = e.target.closest('[data-ws-group]');
if (grp) { setGrouping(grp.dataset.wsGroup); return; }
const pick = e.target.closest('[data-ws-select]');
if (pick && !e.metaKey && !e.ctrlKey && !e.shiftKey && e.button === 0) { e.preventDefault(); setQuery({ d: pick.dataset.wsSelect }); }
});
// SP8: the Organizations tile counts the Dashboard's own table, so a plain click moves focus there.
document.addEventListener('click', e => {
const jump = e.target.closest?.('[data-ws-jump="orgs"]');
if (!jump || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0) return;
const to = document.querySelector('[data-ws-orgs-h]');
if (to) { e.preventDefault(); to.focus(); }
});
document.addEventListener('change', e => {
if (e.target.matches?.('[data-ws-projects] [data-ws-status]')) setQuery({ status: e.target.value === 'active' ? null : e.target.value });
else if (e.target.matches?.('[data-ws-projects] [data-ws-state]')) setQuery({ state: e.target.value || null });
});
// Typing writes the hash at once, so a poll repaint keeps what was typed; the read waits a beat.
let typing;
document.addEventListener('input', e => {
if (!e.target.matches?.('[data-ws-projects] [data-ws-name]')) return;
setQuery({ name: e.target.value.slice(0, 200) || null }, false);
clearTimeout(typing); typing = setTimeout(() => document.dispatchEvent(new CustomEvent('mosaic-workspace-render')), 250);
});
// U4b: the org mark (colour and initials) for the task board (tasks-board.js).
const orgMark = Object.freeze({ ready: ensureThemes, av, colours, initials });
window.MosaicWorkspace = Object.freeze({ dashboard, afterPaint, holdLive, graftLive, agentGrid, icon, orgMark, refresh: () => refresh(), av, colours, label, state, dot, themes: ensureThemes, home, projectsPage, inboxPage, agentsPage, inboxCount, setGrouping, orgsOf, orgChip, projChip, unreadNote, setQuery, classWord, get pollMs() { return pollMs; } });
refresh();
})();