@idleware/ringi 0.5.0 → 0.6.1

package/target/esm/cli/shared.js

@@ -1,159 +0,0 @@
-// shared: commands the operator and agents both run: messages, threads, work, signals, proposals and grants. Each
-// parses its arguments, calls one app operation and prints the result.
-import fs from 'node:fs';
-import path from 'node:path';
-import * as Budget from '../app/budget.js';
-import * as Room from '../app/room.js';
-import { checkPath, withSizes } from '../app/room.js';
-import { asJson, oneLine, render } from '../app/view.js';
-import { bytes, fail, note, short, when, words } from '../lib/index.js';
-import { attachments, dump, flag, list, opt, out, textOf } from './args.js';
-const sendInput = (o) => ({ text: textOf(o), to: words(opt(o, 'to')), all: flag(o, 'all'), task: flag(o, 'task'),
-    state: opt(o, 'state'), assign: opt(o, 'assign') ? words(opt(o, 'assign')) : undefined, roles: opt(o, 'roles'), grant: opt(o, 'grant'),
-    files: list(o, 'attach').flatMap(attachments) });
-const sent = (r) => out(`sent ${short(r.id)} to ${r.to.join(', ')}${r.files ? ` with ${r.files} file(s)` : ''}`);
-// Stages files for the actor's next message, like git add: their content is taken into the hub now. Without files it
-// lists what is staged; --drop <path> and --clear take files back out.
-export const add = (a, o) => {
-    if (flag(o, 'clear'))
-        Room.unstage(a, null);
-    else if (list(o, 'drop').length)
-        Room.unstage(a, list(o, 'drop'));
-    const staged = o._.length ? Room.stage(a, o._.flatMap(attachments)) : Room.staged(a);
-    out(staged.length ? `staged for your next message:\n${staged.map(s => `  ${s.path} (${bytes(s.size)})`).join('\n')}` : 'nothing staged');
-};
-export const send = (a, o) => sent(Room.send(a, { ...sendInput(o), re: opt(o, 're') }));
-export const reply = (a, o) => sent(Room.send(a, { ...sendInput(o), re: o._[0] ?? fail('usage: reply <msg> -m <text> …'), reply: true }));
-export const read = (a, o) => {
-    const { all, m, replies, marks } = Room.message(a, o._[0] ?? fail('usage: read <msg>'));
-    if (flag(o, 'json'))
-        return dump(asJson(m));
-    out(render(all, m, { files: () => withSizes(a.R, m) }));
-    if (replies.length)
-        out(`replies: ${replies.map(x => `${short(x.id)} (${x.from})`).join(', ')}`);
-    if (marks)
-        out(Object.entries(marks).map(([mark, who]) => `${mark} by: ${who.join(', ')}`).join('; '));
-};
-export const thread = (a, o) => {
-    const { all, msgs } = Room.thread(a, o._[0] ?? fail('usage: thread <msg>'));
-    if (flag(o, 'json'))
-        return dump(msgs.map(asJson));
-    out(msgs.map(m => render(all, m, { files: () => withSizes(a.R, m) })).join('\n\n'));
-};
-export const taskLine = (t) => {
-    const roles = Object.keys(t.roles).length ? ` [${Object.entries(t.roles).map(([id, label]) => `${id}=${label}`).join(' ')}]` : '';
-    return `${short(t.id)}  ${t.state.padEnd(14)} ${t.requester} → ${t.assignees.join(',') || '(open)'}${roles}${t.taken.length ? ` taken by ${t.taken.join(',')}` : ''}${t.grant ? ` grant ${short(t.grant)}` : ''}  ${when(Date.parse(t.at) / 1000).slice(5)} by ${t.by}  ${t.subject}`;
-};
-export const tasks = (a, o) => {
-    const { views } = Room.tasks(a, { all: flag(o, 'all') });
-    if (flag(o, 'json'))
-        return dump(views);
-    if (!views.length)
-        return out(flag(o, 'all') ? 'no work' : `no open work (profile ${a.R.profile.name}; tasks --all for everything)`);
-    for (const t of views)
-        out(taskLine(t));
-};
-export const log = (a, o) => {
-    const msgs = Room.log(a, { agent: opt(o, 'agent'), all: flag(o, 'all'), n: Number(opt(o, 'n') ?? 20) });
-    if (flag(o, 'json'))
-        return dump(msgs.map(asJson));
-    for (const m of msgs)
-        out(oneLine(m));
-};
-export const cat = (a, o) => {
-    const ref = o._[0] ?? fail('usage: cat <msg> [<path>]');
-    const p = o._[1] ?? (() => {
-        const { m } = Room.files(a, ref);
-        return m.files.length === 1 ? m.files[0].path : fail(`${short(m.id)} has ${m.files.length} files; name one: ${m.files.map(f => f.path).join(', ')}`);
-    })();
-    process.stdout.write(Room.files(a, ref, p).files[0].content);
-};
-export const get = (a, o) => {
-    const { m, files } = Room.files(a, o._[0] ?? fail('usage: get <msg> [-o <dir>]'));
-    const dir = path.resolve(opt(o, 'out') ?? short(m.id));
-    for (const f of files) {
-        const dest = path.join(dir, checkPath(f.path));
-        fs.mkdirSync(path.dirname(dest), { recursive: true });
-        fs.writeFileSync(dest, f.content);
-        out(dest);
-    }
-};
-export const who = (a) => {
-    for (const x of Room.members(a))
-        out(`${x.id.padEnd(12)} ${x.role.padEnd(7)} ${String(x.messages).padStart(4)} msg${x.card ? `  ${x.card}` : ''}`);
-};
-export const signals = (a, o) => {
-    const res = Room.signals(a, { repair: flag(o, 'repair') });
-    if (res.repaired !== null)
-        out(`restored ${res.repaired} signal(s) of ${a.me}`);
-    for (const x of res.alarms)
-        note(`ALARM ${x}`);
-    if (flag(o, 'json'))
-        return dump(res.checked);
-    const at = (c) => res.all.get(c.target)?.time ?? 0;
-    const sorted = [...res.checked].sort((x, y) => at(x) - at(y));
-    const shown = flag(o, 'all') ? sorted : sorted.slice(-Number(opt(o, 'n') ?? 20));
-    if (!shown.length)
-        return out('no signals');
-    for (const c of shown)
-        out(`${short(c.target)}  ${when(at(c)).slice(5)}  ${c.actor.padEnd(10)} ${c.signal.padEnd(20)} ${c.ok ? res.all.get(c.target)?.subject ?? '' : `MISMATCH: ${c.why}`}`);
-};
-export const profileCmd = ({ R }, o) => {
-    if (flag(o, 'json'))
-        return dump(R.profile);
-    const P = R.profile;
-    out(`room ${R.name} follows profile ${P.name}${P.description ? `: ${P.description}` : ''}`);
-    out(`opens with Kind: ${P.opens}; states: ${P.states.join(', ')}; initial ${P.initial}; terminal ${P.terminal.join(', ')}${P.waiting ? `; waiting ${P.waiting}` : ''}`);
-    for (const [k, v] of Object.entries(P.rules))
-        out(`  ${k.padEnd(18)} ${(v ?? []).join(', ')}`);
-};
-// --- decisions and budgets ---
-export const propose = (a, o) => {
-    const decider = opt(o, 'decider') ?? fail('--decider <id> is required: who decides (operator, or someone with authority in the hub contract)');
-    const r = Budget.propose(a, { text: textOf(o), decider, reviewers: words(opt(o, 'reviewers')), budget: opt(o, 'budget'), due: opt(o, 'due'),
-        supersedes: opt(o, 'supersedes'), files: list(o, 'attach').flatMap(attachments) });
-    out(`proposed ${short(r.id)} to ${r.to.join(', ') || 'the room'}; decider ${decider}${r.budget ? `, budget ${Budget.budgetText(r.budget)}` : ''}`);
-};
-export const stamp_ = (a, o) => {
-    const s = o._[1] ?? '';
-    if (!Budget.STAMPS.includes(s))
-        fail(`usage: stamp <proposal> ${Budget.STAMPS.join('|')} -m <reason>`);
-    const r = Budget.stamp(a, o._[0] ?? fail('name the proposal'), s, textOf(o));
-    out(`stamped ${short(r.proposal.id)} ${s}: ${short(r.id)}`);
-};
-export const decide = (a, o) => {
-    const d = o._[1] ?? '';
-    if (!Budget.DECISIONS.includes(d))
-        fail(`usage: decide <proposal> ${Budget.DECISIONS.join('|')} -m <reason>`);
-    const r = Budget.decide(a, o._[0] ?? fail('name the proposal'), d, textOf(o));
-    out(`${d} ${short(r.proposal.id)}: ${short(r.id)}${r.budget ? `; grant ${short(r.id)} with ${Budget.budgetText(r.budget)}. Work spends it with --grant ${short(r.id)}` : ''}`);
-};
-export const proposals = (a, o) => {
-    const { proposals: ps, views } = Budget.proposals(a, { all: flag(o, 'all') });
-    if (flag(o, 'json'))
-        return dump(views);
-    if (!ps.length)
-        return out(flag(o, 'all') ? 'no proposals' : 'no open proposals (proposals --all for everything)');
-    for (const x of ps) {
-        const st = x.reviewers.map(r => `${r}:${x.stamps[r]?.stamp ?? '-'}`).join(' ');
-        out(`${short(x.proposal.id)}  ${x.state.padEnd(10)} ${x.proposal.from} → ${x.decider}${x.budget ? `  [${Budget.budgetText(x.budget)}]` : ''}${st ? `  ${st}` : ''}  ${x.proposal.subject}`);
-    }
-};
-export const grants = (a, o) => {
-    const gs = Budget.grants(a);
-    if (flag(o, 'json'))
-        return dump(gs);
-    if (!gs.length)
-        return out('no grants');
-    for (const g of gs) {
-        const u = g.usage;
-        out(`${short(g.grant)}  ${g.revoked ? 'revoked ' : u.left ? 'active  ' : 'spent   '} runs ${u.runs}/${g.budget.runs}, open ${u.open}${u.uncertain ? `, uncertain ${u.uncertain}` : ''}, ${u.seconds}s used, ≤${g.budget['run-seconds']}s a run, concurrency ${g.budget.concurrency}  ${g.subject}`);
-    }
-};
-// What the session may do on its own: the recorded scope; without one, in a room with a quorum the room's work for it,
-// in any other what the operator accepts when asked.
-export const scopeLine = (s, quorum = false) => s.scope
-    ?? (quorum ? 'none recorded; the room\'s work for you, split with the other members' : 'none recorded; ask the operator what to accept');
-// The line that keeps an agent of a room waiting for its quorum from doing anything yet.
-export const waiting = (room, st) => `waiting: room ${room} waits for a quorum of ${st.quorum} agents and has ${st.agents}; nothing to do yet, end the turn. Its work starts by itself at the quorum`;
-//# sourceMappingURL=shared.js.map

package/target/esm/cli/skill.js

@@ -1,54 +0,0 @@
-// skill: installs the agent skill for Claude Code, Codex and Cursor.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { about } from '../app/context.js';
-import { fail } from '../lib/index.js';
-import { flag, out } from './args.js';
-// --- skill ---
-export const SKILL = path.join(about().resources, 'skill', 'ringi');
-export const skillTargets = (project) => {
-    const base = project ? process.cwd() : os.homedir();
-    return [path.join(base, '.claude', 'skills', 'ringi'), path.join(base, '.agents', 'skills', 'ringi')];
-};
-export const skill = (o) => {
-    const sub = o._[0];
-    const same = (dir) => {
-        try {
-            return fs.readFileSync(path.join(dir, 'SKILL.md'), 'utf8') === fs.readFileSync(path.join(SKILL, 'SKILL.md'), 'utf8');
-        }
-        catch {
-            return false;
-        }
-    };
-    if (sub === 'install') {
-        for (const dir of skillTargets(flag(o, 'project'))) {
-            fs.mkdirSync(dir, { recursive: true });
-            fs.cpSync(SKILL, dir, { recursive: true });
-            out(`installed ${dir}`);
-        }
-        return out(`ringi's home is ${about().home}. A sandboxed agent must be allowed to write it; for Codex, the narrowest grant is:
-  [sandbox_workspace_write]
-  writable_roots = ["${about().home}"]
-in ~/.codex/config.toml. Otherwise agents re-run ringi commands with sandbox escalation, which you approve.`);
-    }
-    if (sub === 'status') {
-        for (const p of [false, true])
-            for (const dir of skillTargets(p))
-                out(`${same(dir) ? 'ok      ' : fs.existsSync(dir) ? 'outdated' : 'missing '} ${dir}`);
-        return;
-    }
-    if (sub === 'uninstall') {
-        for (const dir of skillTargets(flag(o, 'project'))) {
-            if (!fs.existsSync(dir))
-                continue;
-            fs.rmSync(dir, { recursive: true });
-            out(`removed ${dir}`);
-        }
-        return;
-    }
-    if (sub === 'show')
-        return void process.stdout.write(fs.readFileSync(path.join(SKILL, 'SKILL.md'), 'utf8'));
-    fail('usage: ringi skill install [--project] | uninstall [--project] | status | show');
-};
-//# sourceMappingURL=skill.js.map

package/target/esm/domain/decisions.js

@@ -1,178 +0,0 @@
-// decide: the extension for decisions and budgets (capability `decisions/1`, docs/spec/decisions-1.md). A proposal circulates
-// to named reviewers, who stamp it; only the named decider, holding authority from the hub's contract, decides. An
-// approval that carries a budget is a grant; work spends against it, and the runner that starts model runs writes
-// the usage receipts. Everything here is a pure fold over messages; nothing trusts a model's own report.
-import { ID_RE, one, ordered } from '../protocol/index.js';
-import { fail } from '../lib/index.js';
-export const CAPABILITY = 'decisions/1';
-export const ROOT = 'operator';
-export const BUDGET_KEYS = ['runs', 'run-seconds', 'concurrency'];
-export const STAMPS = ['approve', 'object', 'abstain'];
-export const DECISIONS = ['approved', 'rejected', 'revoked'];
-const ids = (v) => v === null ? [] : [...new Set(v.split(',').map(x => x.trim()).filter(Boolean))];
-// `runs=5, run-seconds=600, concurrency=1`; undefined if malformed. `runs` is required: a budget without a run count
-// bounds nothing; a zero run time or concurrency would disable the bound it names.
-export const parseBudget = (s) => {
-    if (s === null || s === undefined)
-        return null;
-    const b = {};
-    for (const part of String(s).split(',').map(x => x.trim()).filter(Boolean)) {
-        const m = /^([a-z][a-z-]*)=(\d{1,9})$/.exec(part);
-        if (!m || !BUDGET_KEYS.includes(m[1]) || m[1] in b)
-            return undefined;
-        b[m[1]] = Number(m[2]);
-    }
-    if (!('runs' in b) || b['run-seconds'] === 0 || b.concurrency === 0)
-        return undefined;
-    return { 'run-seconds': 1800, concurrency: 1, ...b };
-};
-export const budgetText = (b) => BUDGET_KEYS.map(k => `${k}=${b[k]}`).join(', ');
-// Relative (`90m`, `2h`, `3d`) or an ISO 8601 time → ISO UTC to the second.
-export const parseDue = (s) => {
-    const rel = /^(\d{1,6})([mhd])$/.exec(s);
-    const t = rel ? Date.now() + Number(rel[1]) * { m: 60e3, h: 3600e3, d: 86400e3 }[rel[2]] : Date.parse(s);
-    if (!Number.isFinite(t))
-        fail(`--due takes 90m, 2h, 3d or an ISO time, not ${s}`);
-    return new Date(t).toISOString().slice(0, 19) + 'Z';
-};
-// Extension trailers are part of a record's validity: a malformed decision record routes nowhere. Returns the reason.
-export const check = (m, isRef) => {
-    if (m.bad)
-        return null;
-    for (const k of ['decider', 'reviewers', 'due', 'budget', 'supersedes', 'stamp', 'decision', 'control', 'grant', 'usage', 'run', 'seconds', 'exit']) {
-        if ((m.trailers[k]?.length ?? 0) > 1)
-            return `duplicate ${k}`;
-    }
-    const ref = (k) => one(m, k) === null || isRef(one(m, k));
-    if (!ref('grant'))
-        return 'malformed Grant';
-    if (!ref('control'))
-        return 'malformed Control';
-    if (one(m, 'budget') !== null && !parseBudget(one(m, 'budget')))
-        return 'malformed Budget';
-    if (m.kind === 'proposal') {
-        if (!ID_RE.test(one(m, 'decider') ?? ''))
-            return 'proposal without a valid Decider';
-        if (!ids(one(m, 'reviewers')).every(x => ID_RE.test(x)))
-            return 'malformed Reviewers';
-        if (one(m, 'due') !== null && !Number.isFinite(Date.parse(one(m, 'due'))))
-            return 'malformed Due';
-        if (!ref('supersedes'))
-            return 'malformed Supersedes';
-    }
-    if (m.kind === 'stamp' && (!m.re || !STAMPS.includes(one(m, 'stamp') ?? '')))
-        return 'stamp without Re or a valid Stamp';
-    if (m.kind === 'decision' && (!m.re || !DECISIONS.includes(one(m, 'decision') ?? '')))
-        return 'decision without Re or a valid Decision';
-    if (m.kind === 'usage') {
-        if (!isRef(one(m, 'grant') ?? '') || !['reserve', 'settle'].includes(one(m, 'usage') ?? '') || !/^[A-Za-z0-9._:-]{1,128}$/.test(one(m, 'run') ?? ''))
-            return 'malformed usage receipt';
-        if (one(m, 'usage') === 'settle' && !/^\d{1,9}$/.test(one(m, 'seconds') ?? ''))
-            return 'usage settle without Seconds';
-    }
-    return null;
-};
-// The root always may; anyone else only within the authority table, and never on their own proposal.
-export const mayDecide = (authority, decider, proposer, budget) => {
-    if (decider === ROOT)
-        return true;
-    if (decider === proposer)
-        return false;
-    const cap = authority?.decide?.[decider];
-    if (!cap)
-        return false;
-    if (!budget)
-        return true;
-    return BUDGET_KEYS.every(k => Number.isFinite(cap[k]) && budget[k] <= cap[k]);
-};
-// A decision names the room's control commit it was made under (`Control`); its authority is the table in effect
-// there. A commit that does not exist yet cannot be named, so a later contract never promotes or demotes a decision.
-const authorized = (m, p, decider, budget, authorityAt) => {
-    if (m.from === ROOT)
-        return true;
-    const table = authorityAt(one(m, 'control'));
-    return m.from === decider && !!table && mayDecide(table, decider, p.from, budget);
-};
-// Everything about one proposal, folded over the messages that answer it, in thread order.
-export const proposalOf = (all, p, authorityAt, now = Date.now() / 1000) => {
-    const decider = one(p, 'decider');
-    const reviewers = ids(one(p, 'reviewers'));
-    const budget = parseBudget(one(p, 'budget')) ?? null;
-    const due = one(p, 'due') ? Date.parse(one(p, 'due')) / 1000 : null;
-    // A revision supersedes only when its author is the proposer or the root.
-    const revisions = ordered([...all.values()].filter(m => !m.bad && m.kind === 'proposal' && one(m, 'supersedes') === p.id && (m.from === p.from || m.from === ROOT)));
-    const answers = ordered([...all.values()].filter(m => !m.bad && m.reId === p.id && (m.kind === 'stamp' || m.kind === 'decision')));
-    const stamps = {};
-    let decision = null;
-    let revoked = null;
-    const superseded = revisions[0] ?? null;
-    const revocation = (m) => !revoked && one(m, 'decision') === 'revoked' && (m.from === decider || m.from === ROOT);
-    // A record after the superseding revision in thread order no longer applies to this revision.
-    for (const m of ordered([...answers, ...(superseded ? [superseded] : [])])) {
-        if (m === superseded)
-            break;
-        // A reviewer's latest stamp counts; its position relative to the decision is only a same-second tie.
-        if (m.kind === 'stamp' && reviewers.includes(m.from))
-            stamps[m.from] = { stamp: one(m, 'stamp'), id: m.id, reason: m.subject };
-        if (m.kind !== 'decision')
-            continue;
-        const d = one(m, 'decision');
-        if (!decision && d !== 'revoked' && m.from === decider && authorized(m, p, decider, budget, authorityAt))
-            decision = { decision: d, id: m.id, by: m.from, time: m.time };
-        else if (decision?.decision === 'approved' && revocation(m))
-            revoked = { id: m.id, by: m.from, time: m.time };
-    }
-    // After a superseding revision, only a revocation of an earlier approval still applies to this one.
-    if (superseded && decision?.decision === 'approved')
-        for (const m of answers)
-            if (revocation(m))
-                revoked = { id: m.id, by: m.from, time: m.time };
-    const missing = reviewers.filter(r => !stamps[r]);
-    const state = revoked ? 'revoked' : decision ? decision.decision : superseded ? 'superseded' : due && now > due ? 'overdue' : 'open';
-    const grant = decision?.decision === 'approved' && budget ? { id: decision.id, budget, proposal: p, revoked: !!revoked } : null;
-    return { proposal: p, decider, reviewers, budget, due, stamps, missing, decision, revoked, superseded, state, grant };
-};
-export const proposals = (all, authorityAt) => [...all.values()].filter(m => !m.bad && m.kind === 'proposal').map(p => proposalOf(all, p, authorityAt));
-export const grantOf = (all, authorityAt, id) => {
-    const d = all.get(id);
-    if (!d || d.bad || d.kind !== 'decision' || !d.reId || !all.get(d.reId))
-        return null;
-    const g = proposalOf(all, all.get(d.reId), authorityAt).grant;
-    return g?.id === id ? g : null;
-};
-// The receipts a grant's ledger counts, in thread order: every reservation, and for each run (its runner and Run id)
-// the first settlement after its reservation, as the first decision counts. A settlement of no reserved run counts
-// nothing.
-const ledger = (all, grant) => {
-    const reserves = [], settled = new Map(), reserved = new Set();
-    for (const m of ordered([...all.values()].filter(m => !m.bad && m.kind === 'usage' && one(m, 'grant') === grant.id))) {
-        const run = `${m.from}/${one(m, 'run')}`;
-        if (one(m, 'usage') === 'reserve') {
-            reserves.push(m);
-            reserved.add(run);
-        }
-        else if (reserved.has(run) && !settled.has(run))
-            settled.set(run, m);
-    }
-    return { reserves, settled };
-};
-// Whether a receipt counts: its Grant names a grant, and that grant's ledger holds it.
-export const counted = (all, authorityAt, m) => {
-    const g = !m.bad && m.kind === 'usage' ? grantOf(all, authorityAt, one(m, 'grant') ?? '') : null;
-    if (!g)
-        return false;
-    const { reserves, settled } = ledger(all, g);
-    return reserves.includes(m) || [...settled.values()].includes(m);
-};
-// Usage from the runners' receipts: every reservation is a run, settled or not; an unsettled one is open while its
-// run could still be going, and uncertain after that.
-export const usageOf = (all, grant, now = Date.now() / 1000) => {
-    const { reserves, settled } = ledger(all, grant);
-    let seconds = 0;
-    for (const m of settled.values())
-        seconds += Number(one(m, 'seconds'));
-    const unsettled = reserves.filter(m => !settled.has(`${m.from}/${one(m, 'run')}`));
-    const open = unsettled.filter(m => now - m.time <= grant.budget['run-seconds'] + 60);
-    return { runs: reserves.length, open: open.length, uncertain: unsettled.length - open.length, seconds, left: Math.max(0, grant.budget.runs - reserves.length) };
-};
-//# sourceMappingURL=decisions.js.map

package/target/esm/domain/profiles.js

@@ -1,96 +0,0 @@
-// profile: what a task is, as data. ringi is a point of coordination, not a methodology: the states of a piece of
-// work, which of them end it, and who may move it, assign it or label people in it are declared by a profile
-// that lives in the hub (`profiles/<name>.json` on main) and is chosen per room. The A2A task model is one such
-// profile (resources/profiles/a2a-1.json); a team or a framework brings its own (architect, reviewer, tester, …).
-// This file interprets any profile; it knows no state, role or rule by name.
-import { HEARTBEATS, ID_RE, TOKEN_RE, one, ordered } from '../protocol/index.js';
-import { fail, strictJson } from '../lib/index.js';
-export const PROFILE_SCHEMA = 'ringi-profile/1';
-export const DEFAULT_PROFILE = 'a2a-1';
-// A hub whose rooms may follow profiles other than the built-in A2A rules declares this capability, so that an older
-// client, which knows only those rules, refuses it instead of misreading it.
-export const PROFILES_CAPABILITY = 'profiles/1';
-const PRINCIPAL_RE = /^(?:requester|assignee|member|role:[a-z][a-z0-9-]*|agent:[a-z0-9]+(?:[._-][a-z0-9]+)*)$/;
-// A profile is refused, not guessed at, when it is not exactly what this schema describes.
-export const parseProfile = (text, label) => {
-    const p = strictJson(text, label);
-    const bad = (why) => fail(`${label}: ${why}`);
-    if (p.schema !== PROFILE_SCHEMA)
-        bad(`schema ${String(p.schema)} is not ${PROFILE_SCHEMA}; upgrade ringi or fix the profile`);
-    if (!ID_RE.test(p.name ?? ''))
-        bad('a profile needs a name like team-flow-1');
-    if (!TOKEN_RE.test(p.opens ?? ''))
-        bad('`opens` names the Kind that opens a piece of work');
-    if (!Array.isArray(p.states) || !p.states.length || !p.states.every(s => TOKEN_RE.test(s)) || new Set(p.states).size !== p.states.length)
-        bad('`states` must be distinct tokens');
-    if (!p.states.includes(p.initial))
-        bad('`initial` must be one of the states');
-    if (!Array.isArray(p.terminal) || !p.terminal.every(s => p.states.includes(s)))
-        bad('`terminal` must list states');
-    if (p.waiting !== undefined && (!p.states.includes(p.waiting) || p.terminal.includes(p.waiting)))
-        bad('`waiting` must be a state that does not end the work');
-    if (!p.rules || typeof p.rules !== 'object')
-        bad('`rules` is required');
-    for (const [k, v] of Object.entries(p.rules)) {
-        if (!/^(?:assign|roles|grant|state:(?:\*|[a-z][a-z0-9-]*))$/.test(k))
-            bad(`unknown rule ${k}`);
-        if (k.startsWith('state:') && k !== 'state:*' && !p.states.includes(k.slice(6)))
-            bad(`rule ${k} names an unknown state`);
-        if (!Array.isArray(v) || v.length > 64 || !v.every(x => PRINCIPAL_RE.test(x)))
-            bad(`rule ${k} must list principals: requester, assignee, member, role:<label>, agent:<id>`);
-    }
-    return p;
-};
-const allows = (rule, who, t) => !!rule?.some(p => p === 'requester' ? who === t.requester
-    : p === 'assignee' ? t.assignees.includes(who)
-        : p === 'member' ? true
-            : p.startsWith('role:') ? t.roles[who] === p.slice(5)
-                : p === `agent:${who}`);
-export const ruleFor = (profile, state) => profile.rules[`state:${state}`] ?? profile.rules['state:*'];
-// A message belongs to the nearest work item on its Re chain, itself included.
-export const taskFor = (all, m, profile) => {
-    for (let x = m, i = 0; x && i < 100000; x = x.reId ? all.get(x.reId) : undefined, i++)
-        if (x.kind === profile.opens && !x.bad)
-            return x;
-    return null;
-};
-// A work item folds over its messages in thread order. Every right is judged on the work as it was before the
-// message, so a label given in a message authorizes nothing in that same message, while its holder may still hand it
-// over and reassign in one reply. Opening sets the initial state and assignees (Assign, else To minus the opener; none
-// for To: *). The first terminal state is final; assignment and labels may still change after it.
-export const taskOf = (all, root, profile) => {
-    // Heartbeats never take part in work (§6), whatever trailers they carry.
-    const msgs = ordered([...all.values()].filter(m => !m.bad && !(m.kind && HEARTBEATS.has(m.kind)) && taskFor(all, m, profile) === root));
-    const t = { root, msgs, state: profile.initial, by: root.from, at: root.time, requester: root.from, roles: { ...root.roles },
-        assignees: root.assign ?? (root.to.includes('*') ? [] : root.to.filter(x => x !== root.from)), grant: one(root, 'grant'), effects: new Map() };
-    t.effects.set(root.id, ['opened', ...(root.assign ? ['assigned'] : [])]);
-    for (const m of msgs) {
-        if (m === root)
-            continue;
-        const before = { ...t, roles: { ...t.roles }, assignees: [...t.assignees] };
-        const fx = [];
-        if (one(m, 'grant') && allows(profile.rules.grant, m.from, before)) {
-            t.grant = one(m, 'grant');
-            fx.push('grant');
-        }
-        if (m.roles && allows(profile.rules.roles, m.from, before)) {
-            for (const [id, label] of Object.entries(m.roles))
-                label === 'none' ? delete t.roles[id] : t.roles[id] = label;
-            fx.push('roles');
-        }
-        if (m.assign && allows(profile.rules.assign, m.from, before)) {
-            t.assignees = m.assign;
-            fx.push('assigned');
-        }
-        if (m.state && !profile.terminal.includes(t.state) && profile.states.includes(m.state) && allows(ruleFor(profile, m.state), m.from, before)) {
-            Object.assign(t, { state: m.state, by: m.from, at: m.time });
-            fx.push(`state.${m.state}`);
-        }
-        if (fx.length)
-            t.effects.set(m.id, fx);
-    }
-    return t;
-};
-export const tasksIn = (all, profile) => [...all.values()].filter(m => m.kind === profile.opens && !m.bad).map(r => taskOf(all, r, profile));
-export const isOpen = (t, profile) => !profile.terminal.includes(t.state);
-//# sourceMappingURL=profiles.js.map

package/target/esm/domain/signals.js

@@ -1,134 +0,0 @@
-// signals: explicit markers of what happens in a room, beside the messages that carry it. Every effective transition
-// (work opened, assigned, a state reached, a proposal, a counted stamp, the decision, a counted usage receipt) is also
-// a signal of its author on the message that made it: in a git store an annotated tag `<author>.<signal>.<message12>`
-// on that message's commit, with no text of its own, signed on a signed hub. The message's id keeps the name unique;
-// the name, target, author and time are the tag itself. Signals are visible and checkable with the store's own tools
-// (`git tag -v`, a forge's tag list and tag-push webhooks) and cheap to poll.
-//
-// The messages stay the truth. A signal is made only for a transition the fold actually counted (a State the author
-// had no right to makes none). A reader checks every signal against its message and pins the stored object it
-// accepted; a signal that disagrees, or an accepted one that changes or disappears, is an alarm. A signal missing
-// after a crash between message and tag changes nothing and is restored with `signals --repair`.
-//
-// Marks are the second layer, in the same namespace: where attention is, not what was decided. `read` says a message
-// reached its reader (made on delivery); `taken` says a member took a piece of work. A mark changes no state,
-// assignment or budget. It is checked only for being possible: its target is an accepted message of the room, its
-// actor a member; `read` only for a message addressed to the actor or to all, `taken` only for a message that opens
-// work.
-import * as D from './decisions.js';
-import { taskFor, taskOf } from './profiles.js';
-import { HIDDEN, one, visible } from '../protocol/index.js';
-export const MARKS = ['read', 'taken'];
-// A signal's name after its actor: the signal and the message's short id.
-export const signalName = (id, signal) => `${signal}.${id.slice(0, 12)}`;
-// Why the actor cannot put this mark on this message, or nothing when it can.
-export const markWhy = (R, actor, m, mark) => !R.members[actor] ? `${actor} is not a member of ${R.name}`
-    : mark === 'read' ? (m.from === actor ? 'one does not read one\'s own message' : !visible(m, actor, HIDDEN) ? `the message is not delivered to ${actor}` : undefined)
-        : mark === 'taken' ? (m.kind !== R.profile.opens || m.bad ? `the message does not open work (${R.profile.opens})` : undefined)
-            : `unknown mark ${mark}`;
-// The marks on each message that passed the check: target → mark → actors.
-export const marksOn = (checked) => {
-    const by = new Map();
-    for (const c of checked) {
-        if (!c.ok || !MARKS.includes(c.signal))
-            continue;
-        const e = by.get(c.target) ?? {};
-        (e[c.signal] ??= []).push(c.actor);
-        by.set(c.target, e);
-    }
-    return by;
-};
-// The signals a message made, judged on the room as it is now (thread order is fixed, so this does not change).
-export const effective = (R, all, m) => {
-    if (m.bad || m.invalid)
-        return [];
-    const s = [];
-    const work = taskFor(all, m, R.profile);
-    if (work)
-        for (const fx of taskOf(all, work, R.profile).effects.get(m.id) ?? [])
-            if (fx === 'opened' || fx === 'assigned' || fx.startsWith('state.'))
-                s.push(fx);
-    if (m.kind === 'proposal')
-        s.push('proposed');
-    if (m.kind === 'usage' && D.counted(all, R.authorityAt, m))
-        s.push(`usage.${one(m, 'usage')}`);
-    const p = m.reId ? all.get(m.reId) : undefined;
-    if (p?.kind === 'proposal' && !p.bad) {
-        const info = D.proposalOf(all, p, R.authorityAt);
-        if (m.kind === 'stamp' && info.reviewers.includes(m.from))
-            s.push(`stamp.${one(m, 'stamp')}`);
-        if (m.kind === 'decision' && info.decision?.id === m.id)
-            s.push(`decision.${info.decision.decision}`);
-        if (m.kind === 'decision' && info.revoked?.id === m.id)
-            s.push('decision.revoked');
-    }
-    return s;
-};
-// A signal holds when its author made it, it is named after and points at a message of its author in this room, and
-// that message made exactly this signal.
-export const check = (R, all, records) => records.map(x => {
-    const dot = x.name.lastIndexOf('.');
-    const id = x.name.slice(dot + 1);
-    const signal = x.name.slice(0, dot);
-    const m = all.get(x.target);
-    const what = () => {
-        if (!x.target)
-            return 'is not an annotated tag on a message';
-        if (x.tagger !== x.actor)
-            return `was made by ${x.tagger}, not ${x.actor}`;
-        if (id.length !== 12 || !x.target.startsWith(id))
-            return 'is named after another message';
-        if (!m)
-            return 'points at no accepted message of this room';
-        if (MARKS.includes(signal)) {
-            const why = markWhy(R, x.actor, m, signal);
-            if (why)
-                return why;
-        }
-        else {
-            if (m.from !== x.actor)
-                return `points at a message of ${m.from}`;
-            if (!effective(R, all, m).includes(signal))
-                return `its message did not make ${signal}`;
-        }
-        // A signal is its name and its target; any text besides a signature is not one.
-        if (x.text !== '')
-            return 'carries text; a signal has none';
-        return undefined;
-    };
-    const why = what();
-    return { ref: x.ref, actor: x.actor, signal, target: x.target, ok: !why, why };
-});
-// A signal's identity in any store and after an archive: its tag's name `<actor>.<signal>.<message12>`. Pins an older
-// reader kept as `<actor>/<message>.<signal>`, or under a full ref ending so, read the same way.
-const keyOf = (ref) => {
-    const parts = ref.split('/'), last = parts.at(-1);
-    const old = /^([0-9a-f]{40,64})\.(.+)$/.exec(last);
-    return old && parts.length >= 2 ? `${parts.at(-2)}.${old[2]}.${old[1].slice(0, 12)}` : last;
-};
-// A reader's pins: the stored object of each signal it accepted. A changed or vanished one is an alarm.
-export const pins = (records, checked, accepted = {}) => {
-    const now = new Map(records.map(x => [`${x.actor}.${x.name}`, x]));
-    const alarms = [];
-    const next = {};
-    for (const [k, object] of Object.entries(accepted)) {
-        const key = keyOf(k), x = now.get(key);
-        // Two old pins of one signal (its live and its archived ref) that disagree: keep the first as accepted and the
-        // other under its own ref as evidence, so the conflict is reported on every read until it is resolved.
-        if (key in next && next[key] !== object) {
-            alarms.push(`signal ${key} has two different accepted objects (${next[key]} and ${object})`);
-            next[k] = object;
-            continue;
-        }
-        next[key] = object;
-        if (!x)
-            alarms.push(`signal ${key} was removed after it was accepted`);
-        else if (x.object !== object)
-            alarms.push(`signal ${x.ref} was replaced after it was accepted`);
-    }
-    for (const c of checked)
-        if (c.ok && !next[keyOf(c.ref)])
-            next[keyOf(c.ref)] = now.get(keyOf(c.ref)).object;
-    return { accepted: next, alarms };
-};
-//# sourceMappingURL=signals.js.map