@idleware/ringi 0.6.1 → 0.7.1

package/target/esm/core/agents/sessions/wait.js

@@ -1,47 +1,26 @@
-// wait: an agent holds the line until something new arrives for it or the room falls silent, answering pings.
-import { HIDDEN, append, pongText } from '../../hub/rooms/index.js';
+// wait: an agent holds the line until something new arrives for it, or at most `max` seconds (and never past 110, so
+// a tool call that runs it is not cut off).
+import { HIDDEN } from '../../hub/rooms/index.js';
 import { fail, sleep } from '../../../lib/index.js';
-import { link, unread } from '../../hub/protocol/index.js';
+import { unread } from '../../hub/protocol/index.js';
 import { loadRoom } from '../../hub/history/index.js';
 import { bound } from './index.js';
 import { inbox } from './agent.js';
 export const wait = async (a, { max = 120, ...options } = {}) => {
     if (!Number.isFinite(max) || max < 0)
         fail('wait max must be nonnegative seconds');
-    const start = Date.now(), ponged = new Set();
-    let last = start, silence = Math.min(max, 110);
+    const start = Date.now(), until = start + Math.min(max, 110) * 1000;
     for (;;) {
         // Each poll renews the lease and checks stop, takeover, membership and the room's identity.
         const current = bound();
         if (current.R.genesis !== a.R.genesis || current.me !== a.me)
             fail('the waiting session changed its binding');
-        const { R, me } = current;
-        const { logs, st } = loadRoom(R, me);
-        if (unread(logs, me, st.seen ?? {}, Infinity, HIDDEN).msgs.length)
+        const { logs, st } = loadRoom(current.R, current.me);
+        if (unread(logs, current.me, st.seen ?? {}, Infinity, HIDDEN).msgs.length)
             return { inbox: inbox(current, options), seconds: (Date.now() - start) / 1000 };
-        link(logs);
-        const state = { last, silence, ponged };
-        answerPings(current, logs, state);
-        last = state.last;
-        silence = state.silence;
-        const now = Date.now();
-        if (now - last >= silence * 1000 || now - start >= max * 1000)
-            return { inbox: null, seconds: (now - start) / 1000 };
-        await sleep(Math.min(1000, max * 1000 - (now - start)));
+        if (Date.now() >= until)
+            return { inbox: null, seconds: (Date.now() - start) / 1000 };
+        await sleep(Math.min(1000, until - Date.now()));
     }
 };
-const answerPings = (a, logs, state) => {
-    for (const m of logs.get(a.me) ?? [])
-        if (m.kind === 'pong' && m.reId)
-            state.ponged.add(m.reId);
-    for (const msgs of logs.values())
-        for (const m of msgs) {
-            if (m.kind !== 'ping' || m.bad || !m.to.includes(a.me) || state.ponged.has(m.id))
-                continue;
-            state.ponged.add(m.id);
-            state.last = Date.now();
-            state.silence = Math.max(state.silence, Number(m.trailers.next?.[0]) || 600);
-            append(a.R, a.me, pongText(a.me, m, 'is waiting'));
-        }
-};
 //# sourceMappingURL=wait.js.map

package/target/esm/core/hub/capabilities.js

@@ -1,9 +1,11 @@
 // The capabilities this build enforces: `<name>/<major>` → the module whose folds apply it. A new major is a new module
 // registered beside the old one. A hub contract selects at most one major of each name; a room applies what its
 // contract base selects (docs/ARCHITECTURE.md, Evolution).
-import * as decisions from './decisions/index.js';
 import * as profiles from './work/index.js';
-export const CAPABILITIES = { [decisions.CAPABILITY]: decisions, [profiles.PROFILES_CAPABILITY]: profiles };
+// decisions/1 (proposals, grants, budgets) is retired: nothing in this build creates, decides or spends what it
+// governs, so a contract that still names it restricts nothing here and is read.
+const RETIRED = {};
+export const CAPABILITIES = { [profiles.PROFILES_CAPABILITY]: profiles, 'decisions/1': RETIRED };
 // Why a contract's capability list cannot be enforced by this build, or nothing.
 export const unenforceable = (ids) => {
     const names = ids.map(id => id.split('/')[0]);

package/target/esm/core/hub/history/index.js

@@ -59,7 +59,9 @@ const acceptSignals = (R, logs, st, alarms) => {
 // What follows from an alarm, by what it is about.
 const remedy = (R, alarm) => {
     if (alarm.startsWith('signal '))
-        return 'the messages stay the truth; the author restores a missing signal with ringi agent signals --repair';
+        return alarm.endsWith('was removed after it was accepted')
+            ? 'the messages stay the truth; its author restores it with ringi agent signals --repair'
+            : 'the messages stay the truth; the signal is ignored';
     if (alarm.startsWith('commit '))
         return 'it is skipped; the room reads on without it';
     return `it is quarantined and withheld. Restore it, or the operator runs ringi forget ${R.name}/<log>`;

package/target/esm/core/hub/ports/store.js

@@ -1,7 +1,7 @@
-// store: the port every storage type implements, each an adapter (adapters/transport-<type>: git, kafka and temporal
-// planned) that composition/ registers. Rooms, accepted history, profiles, decisions and signals use only this
+// store: the port every storage type implements, each an adapter (adapters/transport-<type>) that composition/
+// registers. Rooms, accepted history, profiles and signals use only this
 // interface; git is the first implementation, and a hub's descriptor names which one it uses (`store.type`). A store
-// keeps the shared contract (versioned files the participants agree on: contract.json, authority.json, profiles), the
+// keeps the shared contract (versioned files the participants agree on: contract.json, profiles), the
 // rooms (a control record with versioned files, members and roster, and one append-only log per member) and signals
 // (named markers on log entries); the port is split by what each part does (Log, Attachments, …).
 // Revisions are opaque, store-assigned ids. A store says whether one revision extends another; ringi builds the

package/target/esm/core/hub/protocol/index.js

@@ -1,6 +1,6 @@
-// protocol: the message protocol, docs/spec/core-1.md (§3, §5–§7), independent of storage and of any task model. A store
-// turns its records into messages and hands them here: the text (text.ts), threads and order (threads.ts), inboxes and
-// waking (reading.ts). What a task is, which states it has and who may move it, is a profile, not part of the protocol.
+// protocol: the message protocol, docs/spec/core-1.md (§3, §5, §6), independent of storage and of any task model. A store
+// turns its records into messages and hands them here: the text (text.ts), threads and order (threads.ts), inboxes
+// (reading.ts). What a task is, which states it has and who may move it, is a profile, not part of the protocol.
 export * from './model.js';
 export * from './text.js';
 export * from './threads.js';

package/target/esm/core/hub/protocol/model.js

@@ -8,8 +8,7 @@ export const TRAILER_RE = /^([A-Za-z][A-Za-z0-9-]*):[ \t]*(.*)$/;
 export const TEXT_MAX = 64 * 1024;
 // Trailers the protocol itself interprets; any other trailer belongs to an extension or a profile.
 export const KNOWN = new Set(['to', 're', 'kind', 'state', 'hop', 'assign', 'roles']);
-export const HEARTBEATS = new Set(['ping', 'pong']);
-// Kinds that are bookkeeping, never delivered to an inbox: heartbeats, usage receipts, cards, room records.
-export const HIDDEN = new Set(['ping', 'pong', 'usage', 'card', 'room']);
+// Kinds that are bookkeeping, never delivered to an inbox: room records.
+export const HIDDEN = new Set(['room']);
 export const one = (m, k) => m.trailers[k]?.[0] ?? null;
 //# sourceMappingURL=model.js.map

package/target/esm/core/hub/protocol/reading.js

@@ -1,11 +1,9 @@
-// reading: what is delivered to whom (core-1 §6) and what wakes it (§7).
+// reading: what is delivered to whom (core-1 §6).
 import { ordered } from './order.js';
 const addressed = (m, id) => m.to.includes(id) || m.to.includes('*');
 const hiddenKind = (m, hidden) => !!m.kind && hidden.has(m.kind);
 // Delivered: well-formed, not a hidden kind, addressed to `id` by name or `*`.
 export const visible = (m, id, hidden) => !m.invalid && !m.bad && !hiddenKind(m, hidden) && addressed(m, id);
-// Wakes: only a direct address. Broadcasts are read when the agent is awake for another reason.
-export const wakes = (m, id, hidden) => visible(m, id, hidden) && m.to.includes(id);
 const after = (msgs, cursor) => msgs.slice(msgs.findIndex(m => m.id === cursor) + 1);
 const others = (logs, id) => [...logs].filter(([log]) => log !== id);
 // Each log's cursor moves past what was shown and what is not for `id`, up to the first message held back.

package/target/esm/core/hub/rooms/compat.js

@@ -42,8 +42,7 @@ export const contractAt = (store, name, rev) => {
     const why = refusal(c, name);
     if (why)
         fail(why);
-    const a = store.contractFile(rev, 'authority.json');
-    return { ...c, authority: a === null ? {} : strictJson(a, `hub ${name}: authority.json at ${short(rev)}`) };
+    return c;
 };
 // Why this ringi cannot read the hub's store as it is laid out (`shown`: what its contract names, or what its store
 // type finds there when the contract names nothing), or nothing; `reads` is what the store type reads.

package/target/esm/core/hub/rooms/hubs.js

@@ -1,7 +1,6 @@
 // hubs: a hub's descriptor beside its store, the contract it carries, and opening it.
 import fs from 'node:fs';
 import path from 'node:path';
-import * as D from '../decisions/index.js';
 import { DEFAULT_PROFILE, PROFILES_CAPABILITY } from '../work/index.js';
 import { hubPorts } from '../ports/index.js';
 import { fail } from '../../../lib/index.js';
@@ -15,17 +14,15 @@ const VERSION = () => hubPorts().build.version;
 const HUB_MD = `# ringi hub
 
 The shared contract of a ringi hub (docs/spec/hub-1.md): contract.json (schema, version, protocol, trust, capabilities, the
-default profile), authority.json (who may decide what, up to which budget; the root, \`operator\`, always may) and
-profiles/ (what a piece of work is in a room: its states, and who may move it). Use \`ringi\`; never edit by hand.
+default profile) and profiles/ (what a piece of work is in a room: its states, and who may move it). Use \`ringi\`; never edit by hand.
 `;
 export const readProfileResource = (name) => fs.readFileSync(path.join(hubPorts().build.resources, 'profiles', `${name}.json`), 'utf8');
 // A new hub: local (asserted senders), or signed, with the operator's root key generated on this machine and pinned.
 // The files of a new hub's first contract.
 const genesisFiles = (d, layout) => {
-    const contract = { schema: 'ringi-hub', version: '1.2', protocol: PROTOCOL_MAJOR, trust: d.trust, store: layout, capabilities: [D.CAPABILITY, PROFILES_CAPABILITY], profile: DEFAULT_PROFILE, ...(d.root ? { root: d.root } : {}) };
+    const contract = { schema: 'ringi-hub', version: '1.2', protocol: PROTOCOL_MAJOR, trust: d.trust, store: layout, capabilities: [PROFILES_CAPABILITY], profile: DEFAULT_PROFILE, ...(d.root ? { root: d.root } : {}) };
     return {
         'contract.json': JSON.stringify(contract, null, 2) + '\n',
-        'authority.json': JSON.stringify({ decide: {} }, null, 2) + '\n',
         'HUB.md': HUB_MD,
         [`profiles/${DEFAULT_PROFILE}.json`]: readProfileResource(DEFAULT_PROFILE),
     };

package/target/esm/core/hub/rooms/index.js

@@ -1,6 +1,6 @@
 // hub: hubs and rooms on top of any store. A hub is a directory with a descriptor (hub.json: which store, where,
-// what this machine pins) beside its store. Its shared contract lives in the store (contract.json, authority.json,
-// profiles/*.json). hubs.ts reads descriptors and contracts, rooms.ts opens rooms with their profile and authority,
+// what this machine pins) beside its store. Its shared contract lives in the store (contract.json, profiles/*.json).
+// hubs.ts reads descriptors and contracts, rooms.ts opens rooms with their profile,
 // messages.ts turns stored records into messages and writes them (docs/spec/hub-1.md).
 import { CAPABILITIES } from '../capabilities.js';
 // The root principal of every hub and room (hub-1): the operator of the machine that made it.
@@ -8,7 +8,7 @@ export const OPERATOR = 'operator';
 export const HUB_MAJOR = 1;
 export const PROTOCOL_MAJOR = 1;
 export const CAPS = new Set(Object.keys(CAPABILITIES));
-export const RESERVED_ROOMS = new Set(['main', 'archive']);
+export const RESERVED_ROOMS = new Set(['main']);
 // Whether the room's work has started: it has the quorum of agents its genesis asked for (`Quorum`), or asked for none.
 export const start = (R) => {
     const agents = Object.values(R.members).filter(m => m.role !== 'root').length;

package/target/esm/core/hub/rooms/messages.js

@@ -1,6 +1,5 @@
 // messages: stored records read as messages, and a message written with the signals it made.
-import * as D from '../decisions/index.js';
-import { compose, decodeText, link, parse } from '../protocol/index.js';
+import { decodeText, link, parse } from '../protocol/index.js';
 import { emit } from '../signals/write.js';
 export const toMessage = (R, from, x, seq) => {
     const trust = R.hub.signed ? 'verified' : 'asserted';
@@ -11,10 +10,9 @@ export const toMessage = (R, from, x, seq) => {
         return { ...base, invalid: d.invalid, subject: '', body: '', to: [], re: null, kind: null, state: null, assign: null, roles: null, hop: 0, bad: d.invalid, trailers: {} };
     }
     const p = parse(d.text, s => R.hub.store.isRef(s));
-    // An extension's trailers and the room profile's states are part of a message's validity.
-    const ext = D.check(p, s => R.hub.store.isRef(s));
+    // The room profile's states are part of a message's validity.
     const state = p.state && !p.bad && !R.profile.states.includes(p.state) ? `State ${p.state} is not in profile ${R.profile.name}` : null;
-    return { ...base, invalid: null, ...p, bad: p.bad ?? ext ?? state };
+    return { ...base, invalid: null, ...p, bad: p.bad ?? state };
 };
 // The room as stored, read without a reader's lock or state: for an author working out the signals of its own message
 // (append runs inside reader locks too). Readers check signals themselves.
@@ -22,10 +20,8 @@ const asStored = (R) => {
     const s = R.hub.store.room(R.name) ?? R.s;
     return link(new Map(R.hub.store.logIds(s).map(id => [id, R.hub.store.messages(s, id, R.hub.store.logHead(s, id)).map((x, seq) => toMessage(R, id, x, seq))])));
 };
-// Whether a message can make signals: it opens, assigns or moves work, or it is a record of the decisions extension.
-const DECISION_KINDS = ['proposal', 'stamp', 'decision', 'usage'];
-const movesWork = (p, R) => p.kind === R.profile.opens || !!p.assign || !!p.state;
-const CARRIES = (p, R) => !p.bad && (movesWork(p, R) || DECISION_KINDS.includes(p.kind ?? ''));
+// Whether a message can make signals: it opens, assigns or moves work.
+const CARRIES = (p, R) => !p.bad && (p.kind === R.profile.opens || !!p.assign || !!p.state);
 // A message on the author's log, and the signals it made (core/hub/signals/write.ts).
 export const append = (R, who, text, entries = []) => {
     const id = R.hub.store.append(R.s, who, text, entries);
@@ -43,5 +39,4 @@ export const withSizes = (R, m) => {
     const sizes = R.hub.store.sizes(m.id, m.files.map(f => f.path));
     return m.files.map(f => ({ ...f, size: sizes.get(f.path) ?? null }));
 };
-export const pongText = (me, m, what) => compose(`pong: ${me} ${what}`, [['To', m.from], ['Re', m.id], ['Kind', 'pong'], ['Hop', String(m.hopEff + 1)]]);
 //# sourceMappingURL=messages.js.map

package/target/esm/core/hub/rooms/rooms.js

@@ -1,48 +1,20 @@
-// rooms: a room opened with its contract, authority, profile, members and quorum; and the root's control changes.
+// rooms: a room opened with its contract, profile, members and quorum; and the root's control changes.
 import { DEFAULT_PROFILE, parseProfile } from '../work/index.js';
 import { locked } from '../ports/index.js';
 import { fail, strictJson } from '../../../lib/index.js';
 import { compose } from '../protocol/index.js';
 import { readProfileResource } from './hubs.js';
 import { contractAt } from './compat.js';
-export const roomNames = (H, archived = false) => H.store.roomNames(archived);
-// No room by that name: quiet, or why, naming an archive it may have become.
-const missing = (H, name, quiet) => {
-    if (quiet)
-        return null;
-    const gone = roomNames(H, true).find(a => a.startsWith(`${name}@`));
-    return fail(gone ? `room ${name} is archived as ${gone}; read it with --room ${gone}` : `no room ${name} in hub ${H.name}; rooms: ${roomNames(H).join(', ') || 'none'}`);
-};
+export const roomNames = (H) => H.store.roomNames();
+const missing = (H, name, quiet) => quiet ? null : fail(`no room ${name} in hub ${H.name}; rooms: ${roomNames(H).join(', ') || 'none'}`);
 // The genesis names its room, in the root's hand: a history offered under another name is not that room.
 const checkNamed = (s, name) => {
-    const named = s.archived ? name.slice(0, name.lastIndexOf('@')) : name;
     const subject = s.control[0]?.rev === s.genesis ? s.control[0].text.split('\n')[0] : '(none)';
-    const archiveName = !s.archived || name === `${named}@${s.genesis.slice(0, 8)}`;
-    if (subject !== `room ${named}` || !archiveName)
+    if (subject !== `room ${name}`)
         fail(`room ${name}: its genesis is "${subject}"; refusing a room's history under another name`);
 };
-// The contract in effect at each control entry: the hub contract the room was created on, then each `Contract:` the
-// operator moved it to. A decision names the control entry it was made under (core/hub/decisions/proposal.ts).
-const contracts = (s) => {
-    const atControl = new Map();
-    let current = s.base;
-    for (const rec of s.control) {
-        current = /^Contract: ([0-9a-f]{40,64})$/m.exec(rec.text)?.[1] ?? current;
-        atControl.set(rec.rev, current);
-    }
-    return { atControl, current };
-};
-const authorityOf = (H, atControl) => {
-    const tables = new Map();
-    return control => {
-        const rev = control ? atControl.get(control) : undefined;
-        if (!rev)
-            return null;
-        if (!tables.has(rev))
-            tables.set(rev, contractAt(H.store, H.name, rev).authority);
-        return tables.get(rev);
-    };
-};
+// The contract the room follows: the hub contract it was created on, or the last one the operator moved it to.
+const contractRev = (s) => s.control.reduce((current, rec) => /^Contract: ([0-9a-f]{40,64})$/m.exec(rec.text)?.[1] ?? current, s.base);
 // The room's profile is fixed when the room is made: its content is copied into the genesis control entry, so no
 // later change of the hub's profiles or contract reinterprets the room's history. Rooms made before this carry none
 // and use the default profile of the contract they were created on.
@@ -61,11 +33,10 @@ export const openRoom = (H, name, { quiet = false } = {}) => {
     if (!s)
         return missing(H, name, quiet);
     checkNamed(s, name);
-    const { atControl, current } = contracts(s);
+    const current = contractRev(s);
     const contract = current === H.main ? H.contract : contractAt(H.store, H.name, current);
-    return { hub: H, s, name, archived: s.archived, head: s.head, genesis: s.genesis, contractRev: current, contract,
-        authorityAt: authorityOf(H, atControl), profile: parseProfile(profileOf(H, s, name), `room ${name}: profile`),
-        members: membersOf(H, s, name), quorum: quorumOf(s) };
+    return { hub: H, s, name, head: s.head, genesis: s.genesis, contractRev: current, contract,
+        profile: parseProfile(profileOf(H, s, name), `room ${name}: profile`), members: membersOf(H, s, name), quorum: quorumOf(s) };
 };
 export const room = (H, name) => openRoom(H, name);
 export const ROOM_MD = (name) => `# room ${name}\n\nA ringi room: members.json lists who takes part; profile.json is what a piece of work is here, fixed when the room was made.\n`;

package/target/esm/core/hub/signals/effective.js

@@ -1,31 +1,11 @@
 // effective: the signals a message made, judged on the room as it is now (thread order is fixed, so this does not
 // change).
-import * as D from '../decisions/index.js';
 import { taskFor, taskOf } from '../work/index.js';
-import { one } from '../protocol/index.js';
 const isWorkSignal = (fx) => fx === 'opened' || fx === 'assigned' || fx.startsWith('state.');
 // What the message did to its piece of work: opened, assigned, a state.
 const workSignals = (R, all, m) => {
     const work = taskFor(all, m, R.profile);
     return work ? (taskOf(all, work, R.profile).effects.get(m.id) ?? []).filter(isWorkSignal) : [];
 };
-// A proposal, and a usage receipt its grant's ledger counts.
-const ownSignals = (R, all, m) => [
-    ...m.kind === 'proposal' ? ['proposed'] : [],
-    ...m.kind === 'usage' && D.counted(all, R.authorityAt, m) ? [`usage.${one(m, 'usage')}`] : [],
-];
-// An answer to a proposal: a counted stamp, the decision, its revocation.
-const answerSignals = (R, all, m) => {
-    const p = m.reId ? all.get(m.reId) : undefined;
-    if (p?.kind !== 'proposal' || p.bad)
-        return [];
-    const info = D.proposalOf(all, p, R.authorityAt);
-    const decided = m.kind === 'decision';
-    return [
-        ...m.kind === 'stamp' && info.reviewers.includes(m.from) ? [`stamp.${one(m, 'stamp')}`] : [],
-        ...decided && info.decision?.id === m.id ? [`decision.${info.decision.decision}`] : [],
-        ...decided && info.revoked?.id === m.id ? ['decision.revoked'] : [],
-    ];
-};
-export const effective = (R, all, m) => m.bad || m.invalid ? [] : [...workSignals(R, all, m), ...ownSignals(R, all, m), ...answerSignals(R, all, m)];
+export const effective = (R, all, m) => m.bad || m.invalid ? [] : workSignals(R, all, m);
 //# sourceMappingURL=effective.js.map

package/target/esm/core/hub/signals/index.js

@@ -11,8 +11,8 @@
 // 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
+// reached its reader (made on delivery); `taken` says a member took a piece of work. A mark changes no state
+// or assignment. 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.
 export * from './model.js';

package/target/esm/core/hub/signals/pins.js

@@ -1,5 +1,5 @@
 // pins: a reader's pins, the stored object of each signal it accepted. A changed or vanished one is an alarm.
-// A signal's identity in any store and after an archive: its tag's name `<actor>.<signal>.<message12>`.
+// A signal's identity in any store: its tag's name `<actor>.<signal>.<message12>`.
 const keyOf = (ref) => ref.split('/').at(-1);
 export const pins = (records, checked, accepted = {}) => {
     const now = new Map(records.map(x => [`${x.actor}.${x.name}`, x]));

package/target/esm/core/hub/usecases/hubs.js

@@ -1,5 +1,4 @@
 // hubs: the operator's hubs on this machine: list, create, switch, add a signed replica, amend the shared contract.
-import fs from 'node:fs';
 import { DEFAULT_PROFILE, PROFILES_CAPABILITY, parseProfile } from '../work/index.js';
 import { OPERATOR, config, createHub, hubNames, openHub, roomNames, setConfig, transportOf } from '../rooms/index.js';
 import { hubPorts } from '../ports/index.js';
@@ -56,8 +55,6 @@ const setKeys = (contract, set) => {
 // The files the amendment brings besides the contract; a profile is checked before it reaches the contract.
 const extraFiles = (x) => {
     const files = {};
-    if (x.authority)
-        files['authority.json'] = json(strictJson(fs.readFileSync(x.authority, 'utf8'), x.authority));
     for (const f of x.files ?? []) {
         if (/^profiles\/[^/]+\.json$/.test(f.path))
             parseProfile(f.content.toString('utf8'), f.path);

package/target/esm/core/hub/usecases/room.js

@@ -53,10 +53,9 @@ export const files = ({ R, me }, ref, path) => {
     return { m, files: m.files.filter(f => !path || f.path === path).map(f => ({ path: f.path, content: R.hub.store.file(m.id, f.path) })) };
 };
 export const members = ({ R, me }) => {
-    const { logs, all } = linked(R, me);
-    const cards = new Map(ordered([...all.values()].filter(m => m.kind === 'card' && !m.bad)).map(m => [m.from, m]));
+    const { logs } = linked(R, me);
     return Object.entries(R.members).map(([id, info]) => ({ id, role: info.role ?? 'member',
-        messages: (logs.get(id) ?? []).filter(m => !(m.kind && HIDDEN.has(m.kind))).length, card: cards.get(id)?.subject ?? null }));
+        messages: (logs.get(id) ?? []).filter(m => !(m.kind && HIDDEN.has(m.kind))).length }));
 };
 // --- signals ---
 // The room's signals, each checked against its message and against what this reader accepted before; `repair` first

package/target/esm/core/hub/usecases/rooms.js

@@ -1,4 +1,4 @@
-// rooms: the operator's rooms in a hub: list, create, switch, admit and remove members, archive, delete, move to a
+// rooms: the operator's rooms in a hub: list, create, switch, admit and remove members, delete, move to a
 // newer contract, and accept a new baseline for a log after reviewing an alarm.
 import crypto from 'node:crypto';
 import { DEFAULT_PROFILE, parseProfile } from '../work/index.js';
@@ -22,13 +22,10 @@ const opens = (H, n) => {
         return null;
     }
 };
-export const rooms = (H, { archived = false } = {}) => {
+export const rooms = (H) => {
     const cur = config().room;
-    const view = (n, R) => ({ name: n, current: n === cur && !R.archived, archived: R.archived,
-        members: Object.keys(R.members).length, profile: R.profile.name, genesis: R.genesis });
-    const live = roomNames(H).flatMap(n => { const R = opens(H, n); return R ? [view(n, R)] : []; });
-    const gone = archived ? roomNames(H, true).flatMap(n => { const R = opens(H, n); return R ? [view(n, R)] : []; }) : [];
-    return [...live, ...gone];
+    const view = (n, R) => ({ name: n, current: n === cur, members: Object.keys(R.members).length, profile: R.profile.name, genesis: R.genesis });
+    return roomNames(H).flatMap(n => { const R = opens(H, n); return R ? [view(n, R)] : []; });
 };
 // A room carries its profile from the start: later changes to the hub's profiles do not reach it.
 // `quorum`: the room's work starts by itself once it has that many agents; until then a join waits.
@@ -57,16 +54,6 @@ export const use = (H, name) => {
     setConfig({ hub: H.name, room: R.name });
     return R;
 };
-export const archive = (H, R) => {
-    notSigned(H, 'archive');
-    if (R.archived)
-        fail(`${R.name} is already archived`);
-    const name = `${R.name}@${R.genesis.slice(0, 8)}`;
-    locked(`hub-${H.name}`, () => H.store.archiveRoom(R.s, name));
-    if (config().room === R.name)
-        setConfig({ room: null });
-    return name;
-};
 // The room and everything kept for it: in the store (deleteRoom) and its readers' state. The sessions bound to it,
 // on this machine or another, leave it on their own when they find its branch gone (core/agents/sessions).
 export const erase = (H, R) => {

package/target/esm/core/hub/usecases/roster.js

@@ -5,7 +5,7 @@ import { OPERATOR, controlChange } from '../rooms/index.js';
 import { fail } from '../../../lib/index.js';
 import { AGENT_RE, ID_RE } from '../protocol/index.js';
 import { loadState, readerLock, saveState } from '../history/index.js';
-// Removing, archiving or deleting in a signed hub needs revocation published to every replica: not in this version.
+// Removing or deleting in a signed hub needs revocation published to every replica: not in this version.
 export const notSigned = (H, what) => { if (H.signed)
     fail(`room ${what} is not supported on signed hubs yet: a local change would come back with the next fetch`); };
 export const admit = (H, R, who, key) => {

package/target/esm/core/hub/usecases/send.js

@@ -1,7 +1,6 @@
 // send: a message from the actor, its recipients, trailers and files checked before it is written.
-import * as D from '../decisions/index.js';
 import { OPERATOR, append } from '../rooms/index.js';
-import { fail, note, short } from '../../../lib/index.js';
+import { fail, note } from '../../../lib/index.js';
 import { ID_RE, TOKEN_RE, checkOutgoing, compose, lookup } from '../protocol/index.js';
 import { linked, readerLock } from '../history/index.js';
 import { isRef } from './actor.js';
@@ -44,14 +43,6 @@ const checkTrailers = (P, x, to, assign, re) => {
     if (x.roles && !x.roles.split(',').every(role))
         fail('--roles takes "<id>=<label>, …"; labels mean what the room profile says');
 };
-// The grant a piece of work spends: an approved decision with a budget, not revoked.
-const grantOf = (R, all, ref) => {
-    if (!ref)
-        return null;
-    const d = lookup(all, ref);
-    const g = D.grantOf(all, R.authorityAt, d.id) ?? fail(`${short(d.id)} is not an approved decision with a budget`);
-    return g.revoked ? fail(`grant ${short(g.id)} was revoked`) : g.id;
-};
 // A message from the actor. The operator may omit `to`: the room, or the assignees when there are any.
 export const send = ({ R, me }, x) => {
     const P = R.profile;
@@ -60,12 +51,11 @@ export const send = ({ R, me }, x) => {
     const assign = x.assign ? [...new Set(x.assign)] : null;
     const to = recipients(me, x, re, assign);
     checkTrailers(P, x, to, assign, re);
-    const grant = grantOf(R, all, x.grant);
     const stagedNow = staged({ R, me });
     const entries = outgoing(stagedNow, x.files ?? []);
     const text = compose(x.text, [
         ['To', to.join(', ')], ['Re', re?.id], ['Kind', x.task && P.opens], ['State', x.state], ['Assign', assign?.join(', ')],
-        ['Roles', x.roles], ['Grant', grant], ['Hop', re && String(re.hopEff + 1)],
+        ['Roles', x.roles], ['Hop', re && String(re.hopEff + 1)],
     ]);
     checkOutgoing(text, isRef(R));
     const id = append(R, me, text, entries);

package/target/esm/core/hub/usecases/view.js

@@ -1,4 +1,4 @@
-// view: how messages, work, proposals and grants are shown: as text framed for people and models, and as the JSON
+// view: how messages and work are shown: as text framed for people and models, and as the JSON
 // shapes every interface (the CLI's --json, a control panel) returns.
 import { bytes, when } from '../../../lib/index.js';
 import { KNOWN } from '../protocol/index.js';
@@ -44,9 +44,5 @@ export const asJson = (m) => ({ id: m.id, from: m.from, trust: m.trust, to: m.to
     assign: m.assign, roles: m.roles, hop: m.hop, hopEff: m.hopEff, bad: m.bad, time: new Date(m.time * 1000).toISOString(), subject: m.subject,
     body: m.body, files: m.files.map(f => ({ path: f.path, size: f.size })), refused: m.refused, trailers: m.trailers });
 export const taskView = (t, taken) => ({ id: t.root.id, subject: t.root.subject, requester: t.requester,
-    assignees: t.assignees, roles: t.roles, taken, grant: t.grant, state: t.state, by: t.by, at: new Date(t.at * 1000).toISOString() });
-export const proposalView = (x) => ({ id: x.proposal.id, subject: x.proposal.subject, from: x.proposal.from,
-    decider: x.decider, state: x.state, budget: x.budget, stamps: x.stamps, missing: x.missing });
-export const grantView = (x, usage) => ({ grant: x.grant.id, proposal: x.proposal.id,
-    subject: x.proposal.subject, budget: x.grant.budget, revoked: x.grant.revoked, usage });
+    assignees: t.assignees, roles: t.roles, taken, state: t.state, by: t.by, at: new Date(t.at * 1000).toISOString() });
 //# sourceMappingURL=view.js.map

package/target/esm/core/hub/work/task.js

@@ -1,5 +1,5 @@
 // task: a piece of work folded over its messages in thread order, by the room's profile.
-import { HEARTBEATS, one, ordered } from '../protocol/index.js';
+import { ordered } from '../protocol/index.js';
 // Who a principal of a rule is in a piece of work.
 const PRINCIPALS = {
     requester: (who, t) => who === t.requester,
@@ -16,12 +16,6 @@ export const taskFor = (all, m, profile) => {
             return x;
     return null;
 };
-const grant = (profile, t, b, m) => {
-    if (!one(m, 'grant') || !allows(profile.rules.grant, m.from, b))
-        return null;
-    t.grant = one(m, 'grant');
-    return 'grant';
-};
 const roles = (profile, t, b, m) => {
     if (!m.roles || !allows(profile.rules.roles, m.from, b))
         return null;
@@ -43,12 +37,11 @@ const state = (profile, t, b, m) => {
     Object.assign(t, { state: m.state, by: m.from, at: m.time });
     return `state.${m.state}`;
 };
-const STEPS = [grant, roles, assign, state];
+const STEPS = [roles, assign, state];
 const opening = (root, profile, msgs) => ({ 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([[root.id, ['opened', ...(root.assign ? ['assigned'] : [])]]]) });
-// Heartbeats never take part in work (§6), whatever trailers they carry.
-const partOf = (all, m, root, profile) => !m.bad && !(m.kind && HEARTBEATS.has(m.kind)) && taskFor(all, m, profile) === root;
+    effects: new Map([[root.id, ['opened', ...(root.assign ? ['assigned'] : [])]]]) });
+const partOf = (all, m, root, profile) => !m.bad && taskFor(all, m, profile) === root;
 // 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

package/target/esm/index.js

@@ -1,10 +1,9 @@
-// The library: the message protocol, profiles, decisions, signals and the Store port, for programs that coordinate
+// The library: the message protocol, profiles, signals and the Store port, for programs that coordinate
 // through ringi without its command line (a framework's own runner, another store, another client).
 // Importing it wires this machine's defaults (composition/); a program that brings its own adapters calls wire().
 import './composition/index.js';
 export * from './core/hub/protocol/index.js';
 export * from './core/hub/work/index.js';
-export * as decide from './core/hub/decisions/index.js';
 export * as signals from './core/hub/signals/index.js';
 export { openHub, openRoom, createHub, contractAt } from './core/hub/rooms/index.js';
 //# sourceMappingURL=index.js.map

package/target/esm/lib/json.js

@@ -1,5 +1,5 @@
 // json: JSON read strictly. JSON.parse silently keeps the last of duplicate
-// fields; for contracts and authority that hides a second value, so the structure is checked first and a duplicate
+// fields; for contracts and profiles that hides a second value, so the structure is checked first and a duplicate
 // field is refused.
 import { fail } from './fail.js';
 const LITERAL = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/;

package/target/dts/adapters/host-posix/group-state.d.ts

@@ -1,7 +0,0 @@
-export type GroupMember = {
-    group: number;
-    state: string;
-};
-export declare const procMember: (text: string) => GroupMember | null;
-export declare const psMember: (text: string) => GroupMember | null;
-export declare const groupRunning: (group: number, members: Array<GroupMember | null>) => boolean | null;

package/target/dts/adapters/host-posix/groups.d.ts

@@ -1 +0,0 @@
-export declare const groupAlive: (group: number) => boolean;

package/target/dts/adapters/host-posix/launch.d.ts

@@ -1,7 +0,0 @@
-import type { Clock, Ended, Launch } from '../../core/agents/ports/host.ts';
-type Running = {
-    done: Promise<Ended>;
-    stop(): void;
-};
-export declare const launch: (request: Launch, clock: Clock) => Running;
-export {};

package/target/dts/adapters/host-posix/probes.d.ts

@@ -1,5 +0,0 @@
-import type { Ancestor, ProcessRows } from '../../core/agents/ports/host.ts';
-export declare const supported: boolean;
-export declare const alive: (pid: number) => boolean;
-export declare const snapshot: () => ProcessRows | null;
-export declare const ancestors: (first: number) => Ancestor[];

package/target/dts/adapters/host-posix/stats.d.ts

@@ -1,9 +0,0 @@
-export declare const seconds: (time: string) => number;
-export declare const procStat: (line: string) => {
-    ppid: number;
-    cpu: number;
-} | null;
-export declare const treeCpu: (pid: number, rows: Map<number, {
-    ppid: number;
-    cpu: number;
-}> | null) => number | null;

package/target/dts/adapters/transport-kafka/index.d.ts

@@ -1,2 +0,0 @@
-import type { Transport } from '../../core/hub/ports/store.ts';
-export declare const kafka: Transport;

package/target/dts/adapters/transport-temporal/index.d.ts

@@ -1,2 +0,0 @@
-import type { Transport } from '../../core/hub/ports/store.ts';
-export declare const temporal: Transport;