team 0.0.1 → 0.1.0

package/dist/yaml.js

@@ -0,0 +1,380 @@
+// A parser for the YAML subset a team file is written in: block maps and sequences, flow maps
+// and sequences on one line, plain and quoted scalars, comments. Anything else is refused with
+// its line number, since this reads a file that runs commands.
+export class YamlError extends Error {
+    line;
+    constructor(line, message) {
+        super(message);
+        this.name = 'YamlError';
+        this.line = line;
+    }
+}
+export function parseYaml(text) {
+    const lines = readLines(text);
+    if (!lines.length)
+        throw new YamlError(1, 'the file is empty');
+    const state = { lines, at: 0 };
+    const first = lines[0];
+    if (first.indent !== 0)
+        throw new YamlError(first.n, 'the first line must not be indented');
+    const node = parseBlock(state, 0);
+    const rest = state.lines[state.at];
+    if (rest)
+        throw new YamlError(rest.n, 'unexpected indentation');
+    return node;
+}
+export function toValue(node) {
+    if (node.kind === 'scalar')
+        return node.value;
+    if (node.kind === 'seq')
+        return node.items.map(toValue);
+    const out = {};
+    for (const entry of node.entries)
+        out[entry.key] = toValue(entry.value);
+    return out;
+}
+function readLines(text) {
+    const lines = [];
+    const source = text.replace(/^/, '').split(/\r?\n/);
+    for (let i = 0; i < source.length; i++) {
+        const n = i + 1;
+        const full = source[i];
+        const indent = full.length - full.trimStart().length;
+        if (full.slice(0, indent).includes('\t'))
+            throw new YamlError(n, 'a tab in the indentation: use spaces');
+        const body = stripComment(full.slice(indent), n).trimEnd();
+        if (!body)
+            continue;
+        if (body === '---' || body === '...' || body.startsWith('--- ')) {
+            throw new YamlError(n, 'document markers are not supported: one document per file');
+        }
+        if (body.startsWith('%'))
+            throw new YamlError(n, 'directives are not supported');
+        lines.push({ n, indent, text: body });
+    }
+    return lines;
+}
+// A comment starts at a `#` that begins the line or follows a space, outside quotes.
+function stripComment(text, n) {
+    let quote = '';
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            if (quote === '"' && c === '\\')
+                i++;
+            else if (c === quote) {
+                if (quote === "'" && text[i + 1] === "'")
+                    i++;
+                else
+                    quote = '';
+            }
+        }
+        else if ((c === '"' || c === "'") && startsScalar(text, i))
+            quote = c;
+        else if (c === '#' && (i === 0 || text[i - 1] === ' ' || text[i - 1] === '\t'))
+            return text.slice(0, i);
+    }
+    if (quote)
+        throw new YamlError(n, 'a quoted string is not closed on its line');
+    return text;
+}
+// A quote opens a string only where a scalar can start; inside a plain scalar it is a character.
+function startsScalar(text, i) {
+    const before = text.slice(0, i).trimEnd();
+    return before === '' || /[:,\[{-]$/.test(before);
+}
+function parseBlock(state, indent) {
+    const line = state.lines[state.at];
+    return isItem(line.text) ? parseSeq(state, indent) : parseMap(state, indent);
+}
+function isItem(text) {
+    return text === '-' || text.startsWith('- ');
+}
+function parseMap(state, indent) {
+    const start = state.lines[state.at];
+    const entries = [];
+    const seen = new Set();
+    for (;;) {
+        const line = state.lines[state.at];
+        if (!line || line.indent < indent)
+            break;
+        if (line.indent > indent)
+            throw new YamlError(line.n, 'unexpected indentation');
+        if (isItem(line.text))
+            throw new YamlError(line.n, 'a list item where a key was expected');
+        const split = splitKey(line.text, line.n);
+        if (!split)
+            throw new YamlError(line.n, `expected "key: value", found "${clip(line.text)}"`);
+        if (seen.has(split.key))
+            throw new YamlError(line.n, `duplicate key "${split.key}"`);
+        seen.add(split.key);
+        state.at++;
+        entries.push({ key: split.key, line: line.n, value: valueAfterKey(state, indent, split.rest, line.n) });
+    }
+    return { kind: 'map', line: start.n, entries };
+}
+function valueAfterKey(state, indent, rest, n) {
+    if (rest)
+        return parseInline(rest, n);
+    const next = state.lines[state.at];
+    if (next && next.indent > indent)
+        return parseBlock(state, next.indent);
+    // A list may sit at its key's own indentation.
+    if (next && next.indent === indent && isItem(next.text))
+        return parseSeq(state, indent);
+    return { kind: 'scalar', line: n, value: null, quoted: false, raw: '' };
+}
+function parseSeq(state, indent) {
+    const start = state.lines[state.at];
+    const items = [];
+    for (;;) {
+        const line = state.lines[state.at];
+        if (!line || line.indent < indent)
+            break;
+        if (line.indent > indent)
+            throw new YamlError(line.n, 'unexpected indentation');
+        if (!isItem(line.text))
+            break;
+        const after = line.text.slice(1);
+        const rest = after.trimStart();
+        if (!rest) {
+            state.at++;
+            const next = state.lines[state.at];
+            if (next && next.indent > indent)
+                items.push(parseBlock(state, next.indent));
+            else
+                items.push({ kind: 'scalar', line: line.n, value: null, quoted: false, raw: '' });
+        }
+        else if (isItem(rest)) {
+            throw new YamlError(line.n, 'a list directly inside a list item is not supported');
+        }
+        else if (splitKey(rest, line.n)) {
+            // "- key: value" opens a map whose keys align with the first one.
+            const inner = indent + 1 + (after.length - rest.length);
+            state.lines[state.at] = { n: line.n, indent: inner, text: rest };
+            items.push(parseMap(state, inner));
+        }
+        else {
+            state.at++;
+            items.push(parseInline(rest, line.n));
+        }
+    }
+    return { kind: 'seq', line: start.n, items };
+}
+// Splits "key: rest" or "key:". Returns null when the text is not a map entry.
+function splitKey(text, n) {
+    const c = text[0];
+    if (c === '"' || c === "'") {
+        const read = readQuoted(text, 0, n);
+        const tail = text.slice(read.end);
+        if (tail === ':')
+            return { key: read.value, rest: '' };
+        if (tail.startsWith(': '))
+            return { key: read.value, rest: tail.slice(2).trim() };
+        return null;
+    }
+    if (c === '{' || c === '[')
+        return null;
+    if (c === '?' && (text.length === 1 || text[1] === ' '))
+        throw new YamlError(n, 'complex keys ("? ") are not supported');
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] !== ':')
+            continue;
+        if (i === text.length - 1)
+            return checkKey(text.slice(0, i), '', n);
+        if (text[i + 1] === ' ')
+            return checkKey(text.slice(0, i), text.slice(i + 2).trim(), n);
+    }
+    return null;
+}
+function checkKey(key, rest, n) {
+    const trimmed = key.trimEnd();
+    if (!trimmed)
+        throw new YamlError(n, 'an empty key');
+    refuseIndicator(trimmed, n);
+    return { key: trimmed, rest };
+}
+function parseInline(text, n) {
+    const c = text[0];
+    // "a: b: c" and "a: - x" are not values in YAML; a full parser refuses them too.
+    if (c !== '"' && c !== "'" && c !== '{' && c !== '[') {
+        if (/: |:$/.test(text))
+            throw new YamlError(n, 'a value that contains ": " must be quoted');
+        if (isItem(text))
+            throw new YamlError(n, 'a list can\'t start on its key\'s line: put each "- item" on a line of its own');
+    }
+    if (c === '{' || c === '[') {
+        const read = readFlow(text, 0, n);
+        if (text.slice(read.end).trim())
+            throw new YamlError(n, `unexpected text after "${c === '{' ? '}' : ']'}"`);
+        return read.node;
+    }
+    if (c === '"' || c === "'") {
+        const read = readQuoted(text, 0, n);
+        if (text.slice(read.end).trim())
+            throw new YamlError(n, 'unexpected text after a quoted string');
+        return { kind: 'scalar', line: n, value: read.value, quoted: true, raw: text.slice(0, read.end) };
+    }
+    return plain(text, n);
+}
+function plain(text, n) {
+    refuseIndicator(text, n);
+    return { kind: 'scalar', line: n, value: resolve(text), quoted: false, raw: text };
+}
+function refuseIndicator(text, n) {
+    const c = text[0];
+    if (c === '&')
+        throw new YamlError(n, 'anchors ("&") are not supported');
+    if (c === '*')
+        throw new YamlError(n, 'aliases ("*") are not supported: quote a value that starts with "*"');
+    if (c === '!')
+        throw new YamlError(n, 'tags ("!") are not supported');
+    if (c === '|' || c === '>')
+        throw new YamlError(n, 'block scalars ("|", ">") are not supported: write the value on one line');
+    if (c === '@' || c === '`' || c === '%')
+        throw new YamlError(n, `a value can't start with "${c}": quote it`);
+    if (text === '<<')
+        throw new YamlError(n, 'merge keys ("<<") are not supported');
+}
+// YAML 1.2 core schema.
+function resolve(text) {
+    if (text === '~' || /^(null|Null|NULL)$/.test(text))
+        return null;
+    if (/^(true|True|TRUE)$/.test(text))
+        return true;
+    if (/^(false|False|FALSE)$/.test(text))
+        return false;
+    if (/^[-+]?[0-9]+$/.test(text))
+        return Number(text);
+    if (/^0o[0-7]+$/.test(text))
+        return parseInt(text.slice(2), 8);
+    if (/^0x[0-9a-fA-F]+$/.test(text))
+        return parseInt(text.slice(2), 16);
+    if (/^[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?$/.test(text))
+        return Number(text);
+    if (/^[-+]?\.(inf|Inf|INF)$/.test(text))
+        return text.startsWith('-') ? -Infinity : Infinity;
+    if (/^\.(nan|NaN|NAN)$/.test(text))
+        return NaN;
+    return text;
+}
+const ESCAPES = {
+    '0': '\0', a: '\x07', b: '\b', t: '\t', n: '\n', v: '\v', f: '\f', r: '\r', e: '\x1b',
+    ' ': ' ', '"': '"', '/': '/', '\\': '\\', N: '\x85', _: '\xa0', L: '
', P: '
',
+};
+function readQuoted(text, at, n) {
+    const quote = text[at];
+    let out = '';
+    for (let i = at + 1; i < text.length; i++) {
+        const c = text[i];
+        if (quote === "'") {
+            if (c !== "'")
+                out += c;
+            else if (text[i + 1] === "'") {
+                out += "'";
+                i++;
+            }
+            else
+                return { value: out, end: i + 1 };
+        }
+        else if (c === '"') {
+            return { value: out, end: i + 1 };
+        }
+        else if (c === '\\') {
+            const e = text[++i];
+            const width = e === 'x' ? 2 : e === 'u' ? 4 : e === 'U' ? 8 : 0;
+            if (width) {
+                const hex = text.slice(i + 1, i + 1 + width);
+                if (!new RegExp(`^[0-9a-fA-F]{${width}}$`).test(hex))
+                    throw new YamlError(n, `a bad "\\${e}" escape`);
+                out += String.fromCodePoint(parseInt(hex, 16));
+                i += width;
+            }
+            else if (e !== undefined && e in ESCAPES)
+                out += ESCAPES[e];
+            else
+                throw new YamlError(n, `an unknown escape "\\${e ?? ''}" in a double-quoted string`);
+        }
+        else
+            out += c;
+    }
+    throw new YamlError(n, 'a quoted string is not closed on its line');
+}
+function readFlow(text, at, n) {
+    const open = text[at];
+    const close = open === '{' ? '}' : ']';
+    const entries = [];
+    const items = [];
+    const seen = new Set();
+    let i = skipSpaces(text, at + 1);
+    for (;;) {
+        if (i >= text.length)
+            throw new YamlError(n, `"${open}" is not closed on its line`);
+        if (text[i] === close) {
+            const node = open === '{' ? { kind: 'map', line: n, entries } : { kind: 'seq', line: n, items };
+            return { node, end: i + 1 };
+        }
+        if (open === '{') {
+            const key = readFlowScalar(text, i, n, true);
+            if (key.node.kind !== 'scalar')
+                throw new YamlError(n, 'a key in "{ }" must be a plain or quoted word');
+            i = skipSpaces(text, key.end);
+            if (text[i] !== ':')
+                throw new YamlError(n, 'expected "key: value" inside "{ }"');
+            const name = key.node.quoted ? String(key.node.value) : key.node.raw;
+            if (seen.has(name))
+                throw new YamlError(n, `duplicate key "${name}"`);
+            seen.add(name);
+            i = skipSpaces(text, i + 1);
+            const value = readFlowScalar(text, i, n, false);
+            entries.push({ key: name, line: n, value: value.node });
+            i = skipSpaces(text, value.end);
+        }
+        else {
+            const value = readFlowScalar(text, i, n, false);
+            items.push(value.node);
+            i = skipSpaces(text, value.end);
+        }
+        if (text[i] === ',')
+            i = skipSpaces(text, i + 1);
+        else if (text[i] !== close)
+            throw new YamlError(n, `expected "," or "${close}"`);
+    }
+}
+function readFlowScalar(text, at, n, key) {
+    const c = text[at];
+    if (c === '{' || c === '[') {
+        if (key)
+            throw new YamlError(n, 'a key in "{ }" must be a plain or quoted word');
+        return readFlow(text, at, n);
+    }
+    if (c === '"' || c === "'") {
+        const read = readQuoted(text, at, n);
+        return { node: { kind: 'scalar', line: n, value: read.value, quoted: true, raw: text.slice(at, read.end) }, end: read.end };
+    }
+    let end = at;
+    while (end < text.length) {
+        const d = text[end];
+        if (d === ',' || d === ']' || d === '}' || d === '[' || d === '{')
+            break;
+        if (d === ':' && (key || text[end + 1] === ' ' || end + 1 === text.length)) {
+            if (!key)
+                throw new YamlError(n, 'a ": " inside a plain value in "[ ]" or "{ }": quote it');
+            break;
+        }
+        end++;
+    }
+    const raw = text.slice(at, end).trim();
+    if (!raw)
+        throw new YamlError(n, 'an empty value inside "[ ]" or "{ }"');
+    return { node: plain(raw, n), end };
+}
+function skipSpaces(text, at) {
+    let i = at;
+    while (text[i] === ' ')
+        i++;
+    return i;
+}
+function clip(text) {
+    return text.length > 40 ? `${text.slice(0, 40)}…` : text;
+}

package/examples/checks/codex-quota

@@ -0,0 +1,217 @@
+#!/usr/bin/env bun
+// Prints one subscription line from a Codex session rollout.
+//
+// Bun runs this. The check is one JSONL scan, and the owner already has Bun on
+// PATH to run team. It uses only the built-in file modules, so there is no
+// package to install beside the script.
+//
+// team runs a check with an empty environment plus PATH and HOME. CODEX_HOME
+// from the owner's shell never reaches this process, so sessions are read from
+// $HOME/.codex/sessions. When Codex's home is somewhere else, install a two-line
+// wrapper, name that wrapper as the account's check, and let it set CODEX_HOME
+// before it execs this script:
+//
+//   #!/bin/sh
+//   CODEX_HOME=/path/to/codex exec /path/to/codex-quota
+//
+// When that variable is set, sessions are $CODEX_HOME/sessions
+// (codex-rs/utils/home-dir and rollout's SESSIONS_SUBDIR, tag rust-v0.157.0).
+//
+// Files named rollout-*.jsonl are taken newest first. The first that has a
+// token_count event with a primary window is the one used, and at most ten
+// files are opened. A newer session that has only session_meta does not hide
+// the last figure. From that file the last such event is kept. The line's at
+// time is that event's timestamp, so an older figure stays dated. The fields
+// used are that window's used_percent, window_minutes and resets_at, plus the
+// event's timestamp. Nothing else from the file is printed.
+//
+// window_minutes maps to a contract name: 300 session, 1440 daily, 10080 weekly.
+// Any other length has no name, and inventing one would be a false figure.
+// used_percent is rounded to the nearest integer. Below 0 or above 100 cannot
+// be written. A reset in the past, or none, is left off the line.
+//
+// primary is the first line. When it cannot be written, nothing is printed, and
+// an older file is not used in its place.
+// RateLimitSnapshot.secondary (protocol.rs, tag rust-v0.157.0) is a second
+// window in the same event. It is a second line when its window_minutes maps to
+// a different one of the three names. The same window is left off: a repeated
+// window makes the whole reading unknown. A secondary figure that cannot be
+// written is left off, and the primary line still prints. Both lines share the
+// event's timestamp.
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+const WINDOWS = { 300: 'session', 1440: 'daily', 10080: 'weekly' };
+const MAX_ROLLOUTS = 10;
+const LINE =
+  /^(session|daily|weekly) (100|[0-9]{1,2})% used( resets (?:[0-9]+h(?:[0-9]+m)?|[0-9]+m))? at [0-9]{10}$/;
+
+function main() {
+  for (const path of newestRollouts(sessionsDir(), MAX_ROLLOUTS)) {
+    const line = lineFromRollout(readFileSync(path, 'utf8'));
+    if (line === undefined) continue;
+    if (line) process.stdout.write(`${line}\n`);
+    return;
+  }
+}
+
+function sessionsDir() {
+  const codex = process.env.CODEX_HOME;
+  if (codex) return join(codex, 'sessions');
+  const home = process.env.HOME;
+  if (!home) return null;
+  return join(home, '.codex', 'sessions');
+}
+
+/** @param {string | null} root @param {number} limit */
+function newestRollouts(root, limit) {
+  if (!root) return [];
+  /** @type {{ path: string, mtimeMs: number, name: string }[]} */
+  const found = [];
+  walk(root, found);
+  found.sort((a, b) => b.mtimeMs - a.mtimeMs || (a.name < b.name ? 1 : a.name > b.name ? -1 : 0));
+  return found.slice(0, limit).map((file) => file.path);
+}
+
+/** @param {string} dir @param {{ path: string, mtimeMs: number, name: string }[]} found */
+function walk(dir, found) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walk(path, found);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.startsWith('rollout-') || !entry.name.endsWith('.jsonl')) continue;
+    try {
+      found.push({ path, mtimeMs: statSync(path).mtimeMs, name: entry.name });
+    } catch {
+      // A file that disappears between listing and stat is not the newest.
+    }
+  }
+}
+
+/**
+ * The contract line, null when a primary window is present but cannot be
+ * written, or undefined when this file has no token_count with a primary.
+ * A null result stops the scan: this file already has a primary window, and an
+ * older file must not stand in for it.
+ * @param {string} text
+ * @returns {string | null | undefined}
+ */
+function lineFromRollout(text) {
+  const lines = text.split('\n');
+  for (let index = lines.length - 1; index >= 0; index--) {
+    const raw = lines[index]?.trim();
+    if (!raw) continue;
+    const event = tokenCount(raw);
+    if (event === undefined) continue;
+    return event;
+  }
+  return undefined;
+}
+
+/**
+ * undefined: not a token_count with a primary window; keep looking.
+ * null: the latest primary window cannot be written; stop.
+ * string: one contract line, or two when secondary is another window.
+ * @param {string} raw
+ * @returns {string | null | undefined}
+ */
+function tokenCount(raw) {
+  let row;
+  try {
+    row = JSON.parse(raw);
+  } catch {
+    return undefined;
+  }
+  const payload = row?.payload;
+  if (!payload || payload.type !== 'token_count') return undefined;
+  const limits = payload.rate_limits;
+  const primary = limits?.primary;
+  if (primary == null) return undefined;
+  if (typeof primary !== 'object') return null;
+  const line = formatWindow(primary, row.timestamp);
+  if (line === null) return null;
+  const extra = secondaryLine(limits.secondary, row.timestamp, windowName(primary.window_minutes));
+  return extra ? `${line}\n${extra}` : line;
+}
+
+/**
+ * The second line, or '' when secondary is absent, the same window, or cannot
+ * be written. A bad secondary never drops the primary line.
+ * @param {unknown} secondary
+ * @param {unknown} timestamp
+ * @param {string | null} primaryWindow
+ * @returns {string}
+ */
+function secondaryLine(secondary, timestamp, primaryWindow) {
+  if (secondary == null || typeof secondary !== 'object') return '';
+  const record = /** @type {Record<string, unknown>} */ (secondary);
+  const window = windowName(record.window_minutes);
+  if (window === null || window === primaryWindow) return '';
+  return formatWindow(record, timestamp) ?? '';
+}
+
+/** @param {Record<string, unknown>} window @param {unknown} timestamp */
+function formatWindow(window, timestamp) {
+  const used = roundedPercent(window.used_percent);
+  const name = windowName(window.window_minutes);
+  const at = unixSeconds(timestamp);
+  if (used === null || name === null || at === null) return null;
+  const resets = resetPhrase(window.resets_at);
+  if (resets === null) return null;
+  const line = `${name} ${used}% used${resets} at ${at}`;
+  return LINE.test(line) ? line : null;
+}
+
+/** @param {unknown} value */
+function roundedPercent(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 100) return null;
+  return Math.round(value);
+}
+
+/** @param {unknown} minutes */
+function windowName(minutes) {
+  if (typeof minutes !== 'number' || !Number.isFinite(minutes)) return null;
+  return WINDOWS[minutes] ?? null;
+}
+
+/** @param {unknown} timestamp */
+function unixSeconds(timestamp) {
+  const ms = typeof timestamp === 'string' ? Date.parse(timestamp) : NaN;
+  if (!Number.isFinite(ms)) return null;
+  const seconds = Math.floor(ms / 1000);
+  return seconds >= 1_000_000_000 && seconds <= 9_999_999_999 ? String(seconds) : null;
+}
+
+/**
+ * '' when the reset is absent or already past. null when the field is present
+ * and not a finite number of seconds.
+ * @param {unknown} resetsAt
+ */
+function resetPhrase(resetsAt) {
+  if (resetsAt == null) return '';
+  if (typeof resetsAt !== 'number' || !Number.isFinite(resetsAt)) return null;
+  const remaining = Math.floor(resetsAt) - Math.floor(Date.now() / 1000);
+  if (remaining <= 0) return '';
+  const minutes = Math.floor(remaining / 60);
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  if (hours > 0 && rest > 0) return ` resets ${hours}h${rest}m`;
+  if (hours > 0) return ` resets ${hours}h`;
+  return ` resets ${rest}m`;
+}
+
+try {
+  main();
+} catch {
+  // No file, a bad path, or a read error is an unknown figure. Exit 0, no text.
+}

package/examples/team.yaml

@@ -0,0 +1,76 @@
+# beacon's team, in format 1: a fictional example. Every project, seat, model and
+# command in it is invented; nothing of a real roster is here.
+
+format: 1
+project: beacon
+coordinator: claude-keeper    # dispatches work
+operator: claude-signal       # receives the watch's reports and nudges
+
+identity:
+  signature:
+    commits:
+      position: trailer       # last-line | trailer | anywhere
+      exempt: [merge]
+    pull_requests:
+      position: last-line
+      template: "**Agent:** {display} · {role}"
+
+workspace:
+  mode: shared                # every seat works in the project root
+
+machine:                      # checked before each seat is launched, and by the watch
+  load_start: 2.0             # 1-minute load per core above which `up` and `add` refuse
+  load_max: 8.0               # per core, above which the watch reports
+  memory_start: 30%           # free memory below which `up` and `add` refuse
+  memory_min: 10%             # below which the watch reports
+  disk_min: 20GB              # free on the project's volume; both refuse and report
+
+seats:
+  - role: coordinator
+    name: claude-keeper
+    label: coordinator
+    cli: claude-code
+    vendor: anthropic
+    model: Claude Nova
+    version: "2"
+    launch: claude
+
+  - role: operator
+    name: claude-signal
+    label: operator
+    cli: claude-code
+    vendor: anthropic
+    model: Claude Nova
+    version: "2"
+    launch: claude
+
+  - role: implementer
+    name: codex-beacon
+    label: codex
+    cli: codex
+    vendor: openai
+    model: GPT Comet
+    version: "3"
+    display: GPT-3 Comet       # the vendor's spelling, for the signature
+    launch: codex -m gpt-comet-3
+    parked: true               # running, and not reported while idle
+
+  - role: implementer
+    name: cursor-beacon
+    label: cursor
+    cli: cursor
+    vendor: meridian
+    model: Meridian
+    version: "1"
+    launch: cursor-agent       # the model is chosen inside Cursor
+
+  # three seats from one entry: nimbus-beacon, nimbus-beacon-2 and -3
+  - role: implementer
+    name: nimbus-beacon
+    label: nimbus
+    cli: claude-code           # the vendor's model, run by Claude Code
+    vendor: nimbus
+    model: Nimbus
+    version: "1"
+    launch: nimbus-claude      # a launcher on the PATH, holding the account's key and endpoint
+    count: 3