@idleware/ringi 0.6.1 → 0.7.0

package/target/esm/core/agents/heartbeat/index.js

@@ -1,35 +1,29 @@
 // heartbeat: whether an agent is alive, and working or waiting, judged from what its machine shows without asking the
-// model, so no tokens are spent on it. The facts: its process and process tree (ProcessHost, core/agents/ports/host.ts), the trace its tool
-// writes (tools.ts, from the tools this machine knows) and ringi's own session record. What to do about a silent or stuck agent is the orchestrator's.
+// model, so no tokens are spent on it. The facts: whether its process lives (ProcessHost), when its tool last wrote the
+// session's trace (tools.ts) and its last ringi command. What to do about a silent agent is the orchestrator's.
 import { agentPorts } from '../ports/index.js';
 import { toolOf, traceTime } from './tools.js';
-// The facts of one session now; `rows` lets one `ps` call serve many sessions.
-export const probe = (s, waits = null, rows = agentPorts().host.snapshot()) => {
-    const host = agentPorts().host, facts = s.pid ? host.inspect(s.pid, rows) : null;
-    return {
-        at: host.clock.wall() / 1000,
-        alive: facts?.alive ?? null,
-        cpu: s.product === 'watch' ? facts?.cpu ?? null : null,
-        trace: traceTime(s),
-        seen: Date.parse(s.lastSeen) / 1000,
-        stopped: s.state === 'stopped', waits,
-    };
-};
-export const tracedBy = (s) => toolOf(s)?.tool ?? (s.product === 'watch' ? 'watch' : 'none');
-// working: its process tree used CPU since the previous look, or its trace or a ringi command is younger than
-// `active` seconds; waiting: alive but neither, or kept waiting by the operator or its room; gone: its process is
-// known to have ended.
-export const judge = (cur, prev = null, { active = 120, next = 30 } = {}) => {
+// The facts of one session now.
+export const probe = (s, waits = null) => ({
+    at: Date.now() / 1000,
+    alive: s.pid && agentPorts().host.supported ? agentPorts().host.alive(s.pid) : null,
+    trace: traceTime(s),
+    seen: Date.parse(s.lastSeen) / 1000,
+    stopped: s.state === 'stopped', waits,
+});
+export const tracedBy = (s) => toolOf(s)?.tool ?? 'none';
+// working: its trace or a ringi command is younger than `active` seconds; waiting: alive but quiet, or kept waiting by
+// the operator or its room; gone: its process is known to have ended.
+export const judge = (cur, { active = 120, next = 30 } = {}) => {
     const quiet = Math.max(0, Math.round(cur.at - Math.max(cur.seen, cur.trace ?? 0)));
-    const base = { alive: cur.alive, quiet, cpu: cur.cpu, next };
+    const base = { alive: cur.alive, quiet, next };
     if (cur.alive === false)
         return { ...base, state: 'gone', waits: null };
     if (cur.stopped)
         return { ...base, state: 'waiting', waits: 'stopped' };
     if (cur.waits)
         return { ...base, state: 'waiting', waits: cur.waits };
-    const spent = prev?.cpu != null && cur.cpu != null && cur.cpu - prev.cpu >= 0.05;
-    return spent || quiet < active ? { ...base, state: 'working', waits: null } : { ...base, state: 'waiting', waits: 'inbox' };
+    return quiet < active ? { ...base, state: 'working', waits: null } : { ...base, state: 'waiting', waits: 'inbox' };
 };
 // The text of a heartbeat: facts as trailers, no word of the work itself.
 export const body = (b) => [
@@ -37,7 +31,6 @@ export const body = (b) => [
     ...(b.waits ? [`Waits: ${b.waits}`] : []),
     `Alive: ${b.alive === null ? 'unknown' : b.alive ? 'yes' : 'no'}`,
     `Quiet: ${b.quiet}`,
-    ...(b.cpu === null ? [] : [`CPU: ${b.cpu.toFixed(1)}`]),
     `Next: ${b.next}`,
 ].join('\n') + '\n';
 //# sourceMappingURL=index.js.map

package/target/esm/core/agents/heartbeat/pulse.js

@@ -1,7 +1,6 @@
 // heartbeat: the pulse of every session this machine holds, judged from its process and its tool's trace without the
 // model (index.ts). It reads session records only: it never binds a session, renews its lease or marks anything read.
 import * as HB from './index.js';
-import { agentPorts } from '../ports/index.js';
 import { hubPorts } from '../../hub/ports/index.js';
 import { claim, release } from './singleton.js';
 export { ensurePulse } from './singleton.js';
@@ -18,41 +17,27 @@ const roomWaits = (s) => {
         return null;
     }
 };
-// Two looks `sample` seconds apart when a watcher is among them, so the CPU its turn spent shows.
-export const heartbeats = async ({ sample = 1 } = {}) => {
-    const ss = allSessions();
-    const waits = ss.map(roomWaits);
-    const first = ss.map((s, i) => HB.probe(s, waits[i], agentPorts().host.snapshot()));
-    if (ss.some(s => s.product === 'watch'))
-        await sleep(sample * 1000);
-    const rows = agentPorts().host.snapshot();
-    return ss.map((s, i) => ({ session: s, tool: HB.tracedBy(s), beat: HB.judge(HB.probe(s, waits[i], rows), first[i]) }));
-};
-const beatAll = (prev, next) => {
-    const rows = agentPorts().host.snapshot();
-    return allSessions().flatMap((s) => {
-        try {
-            const H = openHub(s.hub);
-            const R = openRoom(H, s.room, { quiet: true });
-            // A gone room: the session leaves it on its own; nothing to beat for.
-            if (!R || R.genesis !== s.genesis || !H.store.heartbeat)
-                return [];
-            const f = HB.probe(s, start(R).started ? null : 'quorum', rows);
-            const b = HB.judge(f, prev.get(s.handle) ?? null, { next });
-            prev.set(s.handle, f);
-            H.store.heartbeat(R.s, s.agent, R.s.tip, HB.body(b));
-            return [{ session: s, beat: b }];
-        }
-        catch (e) {
-            return [{ session: s, error: e.message }];
-        }
-    });
-};
+// Every session here, judged now.
+export const heartbeats = () => allSessions().map(s => ({ session: s, tool: HB.tracedBy(s), beat: HB.judge(HB.probe(s, roomWaits(s))) }));
+const beatAll = (next) => allSessions().flatMap((s) => {
+    try {
+        const H = openHub(s.hub);
+        const R = openRoom(H, s.room, { quiet: true });
+        // A gone room: the session leaves it on its own; nothing to beat for.
+        if (!R || R.genesis !== s.genesis || !H.store.heartbeat)
+            return [];
+        const b = HB.judge(HB.probe(s, start(R).started ? null : 'quorum'), { next });
+        H.store.heartbeat(R.s, s.agent, R.s.tip, HB.body(b));
+        return [{ session: s, beat: b }];
+    }
+    catch (e) {
+        return [{ session: s, error: e.message }];
+    }
+});
 // Beats until no session is left twice in a row, or the home is gone; `once`: one round.
 const beatLoop = async (every, once, log) => {
-    const prev = new Map();
     for (let idle = 0; idle < 2;) {
-        const beats = beatAll(prev, every);
+        const beats = beatAll(every);
         for (const b of beats)
             if (b.error)
                 log(`pulse: ${b.session.agent} in ${b.session.hub}/${b.session.room}: ${b.error}`);

package/target/esm/core/agents/heartbeat/tools.js

@@ -1,7 +1,6 @@
 // tools: which agent tool a session runs in, and when that tool last wrote the session's trace, asked of the tools
 // this machine knows (core/agents/ports/tools.ts). Its modification time is the session's own activity, unlike the CPU of an app
-// process that hosts many sessions. A ringi watcher writes no trace of its own: the CPU of its process tree speaks for
-// its turn (index.ts).
+// process that hosts many sessions.
 import { agentPorts } from '../ports/index.js';
 const traced = (s) => {
     for (const tool of agentPorts().tools) {

package/target/esm/core/agents/overview.js

@@ -1,6 +1,5 @@
-// overview: where things stand for the operator: the hub, the room, who is in, open work and proposals, the latest
+// overview: where things stand for the operator: the hub, the room, who is in, open work, the latest
 // messages, and new ones as they land; and the sessions of this machine.
-import * as D from '../hub/decisions/index.js';
 import { hubPorts, locked } from '../hub/ports/index.js';
 import { HIDDEN, OPERATOR, openHub, room as roomOf } from '../hub/rooms/index.js';
 import { fail } from '../../lib/index.js';
@@ -12,11 +11,11 @@ import { rooms } from '../hub/usecases/rooms.js';
 const sessionView = (s) => ({ ...s, liveness: liveness(s) });
 export const where = (H, name) => {
     if (!name)
-        return { hub: H, room: null, sessions: [], work: [], proposals: [], all: new Map(), messages: [] };
+        return { hub: H, room: null, sessions: [], work: [], all: new Map(), messages: [] };
     const R = roomOf(H, name);
     const { all } = linked(R, OPERATOR);
     return { hub: H, room: R, sessions: allSessions().filter(s => s.hub === H.name && s.genesis === R.genesis).map(sessionView),
-        work: tasks({ R, me: OPERATOR }).views, proposals: D.proposals(all, R.authorityAt).filter(x => ['open', 'overdue'].includes(x.state)),
+        work: tasks({ R, me: OPERATOR }).views,
         all, messages: ordered([...all.values()].filter(m => !(m.kind && HIDDEN.has(m.kind)))) };
 };
 // The visible messages that landed since `seen` (which it extends), read afresh from the store.
@@ -28,9 +27,9 @@ export const arrived = (H, R, seen) => {
     return { all, messages };
 };
 // The hub's rooms, each with how many of its sessions on this machine are active.
-export const roomsActive = (H, o = {}) => {
+export const roomsActive = (H) => {
     const ss = allSessions().filter(s => s.hub === H.name && liveness(s) === 'active');
-    return rooms(H, o).map(v => ({ ...v, active: ss.filter(s => s.genesis === v.genesis).length }));
+    return rooms(H).map(v => ({ ...v, active: ss.filter(s => s.genesis === v.genesis).length }));
 };
 export const sessions = () => {
     hubPorts().state.ensure();

package/target/esm/core/agents/ports/host.js

@@ -1,4 +1,4 @@
-// host: process facts and isolated launches, apart from any operating system or agent tool. A launch is held by an
-// opaque handle; only its host may stop it. A deadline uses the host's monotonic clock, dates its wall clock.
+// host: what the operating system says about this machine's processes, and a detached start, apart from any operating
+// system or agent tool. ringi starts one process of its own (the pulse); agents' processes are their tools'.
 export {};
 //# sourceMappingURL=host.js.map

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

@@ -1,14 +1,12 @@
 // agent: what an agent does in its room as itself: read its inbox (marking what it read), take a piece of work, show
-// who it is, leave its card, wait and ping; the headless watcher is turns/.
-import { HIDDEN, append, start, withSizes } from '../../hub/rooms/index.js';
+// who it is, wait.
+import { HIDDEN, start, withSizes } from '../../hub/rooms/index.js';
 import * as Signals from '../../hub/signals/write.js';
 import { fail } from '../../../lib/index.js';
-import { ID_RE, checkOutgoing, compose, link, lookup, unread } from '../../hub/protocol/index.js';
+import { link, lookup, unread } from '../../hub/protocol/index.js';
 import { linked, loadRoomUnlocked, loadState, readerLock, saveState } from '../../hub/history/index.js';
-import { isRef } from '../../hub/usecases/room.js';
 export { wait } from './wait.js';
 export { bound } from './index.js';
-export { watch } from '../turns/index.js';
 // Whether the agent's room has its quorum and started its work; a room that has not is not read.
 export const started = ({ R }) => start(R);
 export const inbox = ({ R, me }, { peek = false, limit = 20 } = {}) => {
@@ -33,22 +31,4 @@ export const take = ({ R, me }, ref) => {
 export const whoami = ({ s, R }) => ({
     session: s ?? fail('agent identity needs a joined session'), profile: R.profile.name, members: Object.keys(R.members),
 });
-export const card = ({ R, me }, text) => {
-    const message = compose(text, [['To', '*'], ['Kind', 'card']]);
-    checkOutgoing(message, isRef(R));
-    return append(R, me, message);
-};
-export const ping = ({ R, me }, { to, text = 'ping: still working', next = 600, re }) => {
-    if (!ID_RE.test(to))
-        fail(`bad recipient ${to}`);
-    if (!Number.isFinite(next) || next <= 0)
-        fail('ping next must be positive seconds');
-    const { all } = linked(R, me);
-    const mine = [...all.values()].filter(m => m.from === me && m.kind === 'ping' && m.to.includes(to)).at(-1);
-    const pong = mine && [...all.values()].find(m => m.kind === 'pong' && m.from === to && m.reId === mine.id);
-    const parent = re ? lookup(all, re) : null;
-    const message = compose(text, [['To', to], ['Re', parent?.id], ['Kind', 'ping'], ['Next', String(next)], ['Hop', parent && String(parent.hopEff + 1)]]);
-    checkOutgoing(message, isRef(R));
-    return { id: append(R, me, message), to, previous: mine ? { id: mine.id, answeredAt: pong?.time ?? null } : null };
-};
 //# sourceMappingURL=agent.js.map

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

@@ -1,7 +1,7 @@
 // binding: the seat a chat holds, checked on every agent command: joined, not stopped, its room alive and the same
 // room, still a member; a chat whose room is gone leaves it on its own.
 import { locked } from '../../hub/ports/index.js';
-import { openHub, openRoom, roomNames } from '../../hub/rooms/index.js';
+import { openHub, openRoom } from '../../hub/rooms/index.js';
 import { fail, stamp } from '../../../lib/index.js';
 import { dropSession, readSession, saveSession, whoAmI } from './index.js';
 // The binding, checked on every agent command: joined, not stopped, room alive and the same room, still a member.
@@ -22,14 +22,12 @@ export const bound = () => {
 };
 const checkRoomIdentity = (me, s, H, R) => {
     if (!R || R.genesis !== s.genesis) {
-        // The room's branch is gone (deleted, archived, or deleted and made anew): the session leaves it on its own. A hub
-        // that cannot be reached fails above and leaves nothing.
+        // The room's branch is gone (deleted, or deleted and made anew): the session leaves it on its own. A hub that
+        // cannot be reached fails above and leaves nothing.
         locked('sessions', () => { if (readSession(me.handle)?.genesis === s.genesis)
             dropSession(me.handle); });
-        const gone = roomNames(H, true).find(a => a === `${s.room}@${s.genesis.slice(0, 8)}`);
-        fail(gone ? `room ${s.room} was archived as ${gone}; this session left it`
-            : R ? `room ${s.room} was deleted and created again; this session left the old room. The operator joins it anew`
-                : `room ${s.room} is gone from hub ${s.hub}; this session left it`);
+        fail(R ? `room ${s.room} was deleted and created again; this session left the old room. The operator joins it anew`
+            : `room ${s.room} is gone from hub ${s.hub}; this session left it`);
     }
 };
 const renewSession = (me, s) => {

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

@@ -43,15 +43,11 @@ export const saveSession = (s) => hubPorts().state.write(sessionKey(s.handle), s
 export const dropSession = (handle) => hubPorts().state.remove(sessionKey(handle));
 export const pidAlive = (pid) => agentPorts().host.alive(pid);
 // active: in use within the lease by a living process; stopped: paused by the operator; gone: neither. A gone or
-// stopped binding keeps its seat and scope. A watcher is alive exactly while its process is: a run may outlast any
-// lease.
+// stopped binding keeps its seat and scope.
 export const liveness = (s) => s.state === 'stopped' ? 'stopped'
-    : s.product === 'watch' ? (s.pid && pidAlive(s.pid) ? 'active' : 'gone')
-        : Date.now() - Date.parse(s.lastSeen) < LEASE && (!s.pid || pidAlive(s.pid)) ? 'active' : 'gone';
+    : Date.now() - Date.parse(s.lastSeen) < LEASE && (!s.pid || pidAlive(s.pid)) ? 'active' : 'gone';
 export const seatHolder = (hub, genesis, agent, except) => allSessions().find(s => s.hub === hub && s.genesis === genesis && s.agent === agent && s.handle !== except);
-// An explicit chat-to-watch handoff remembers only that chat; it never selects another chat's seat.
-export const ownSession = (handle) => readSession(handle)
-    ?? allSessions().find(s => s.product === 'watch' && s.takenFrom === handle) ?? null;
+export const ownSession = (handle) => readSession(handle);
 export const parseSelector = (sel) => {
     const m = /^(?:([a-z0-9._-]+):)?([^/]+)\/([^/]+)$/.exec(sel ?? '');
     return m ? { hub: m[1] ?? null, room: m[2], agent: m[3] } : fail('a session is named <room>/<agent> or <hub>:<room>/<agent>');

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

@@ -3,15 +3,13 @@ import { locked } from '../../hub/ports/index.js';
 import { OPERATOR, controlChange, openHub, room as roomOf } from '../../hub/rooms/index.js';
 import { fail, note, stamp } from '../../../lib/index.js';
 import { AGENT_RE } from '../../hub/protocol/index.js';
-import { dropSession, liveness, ownSession, pidAlive, readSession, saveSession, seatHolder, whoAmI } from './index.js';
+import { dropSession, liveness, ownSession, readSession, saveSession, seatHolder, whoAmI } from './index.js';
 export const join = ({ hub, room, agent: id, scope }) => {
     const me = whoAmI();
     const agent = id ?? me.product ?? fail('--as <id> is required: this session\'s product is unknown');
     if (!AGENT_RE.test(agent) || agent === OPERATOR)
         fail(`bad agent id ${agent}: lowercase letters, digits, - and _, no dot`);
     const H = openHub(hub), R = roomOf(H, room);
-    if (R.archived)
-        fail(`${room} is archived`);
     if (H.signed) {
         if (!H.store.joinKey)
             fail(`hub ${H.name}: its store cannot make keys`);
@@ -39,8 +37,6 @@ const previousSession = ({ me, H, R, agent, room }) => {
     if (holder)
         fail(`${room}/${agent} is held by another session (${holder.handle}, ${liveness(holder)}). A seat ends only with leave, or the operator's takeover: "continue ${room}/${agent}" in this chat`);
     const mine = ownSession(me.handle);
-    if (mine?.product === 'watch' && mine.pid && pidAlive(mine.pid))
-        fail('this chat handed its seat to a live watcher; stop or leave it before joining another room');
     if (mine && mine.handle !== me.handle)
         dropSession(mine.handle);
     return mine;

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

@@ -1,7 +1,7 @@
 // resume: a chat continues its own seat after a restart, or takes over one the operator names.
 import { hubPorts, locked } from '../../hub/ports/index.js';
 import { fail, note, stamp } from '../../../lib/index.js';
-import { allSessions, dropSession, liveness, ownSession, parseSelector, pidAlive, saveSession, whoAmI } from './index.js';
+import { allSessions, dropSession, liveness, ownSession, parseSelector, saveSession, whoAmI } from './index.js';
 export const resume = (selector) => {
     const me = whoAmI();
     hubPorts().state.ensure();
@@ -37,7 +37,7 @@ const ownTarget = (me) => {
 };
 const takeOver = (me, target) => {
     if (target.handle !== me.handle) {
-        if (liveness(target) === 'active' || (target.product === 'watch' && target.pid && pidAlive(target.pid)))
+        if (liveness(target) === 'active')
             fail(`${target.room}/${target.agent} is held by a live session (${target.handle}); it is not taken over`);
         dropSession(target.handle);
         note(`took over ${target.hub}/${target.room}/${target.agent} from ${target.handle}`);
@@ -46,8 +46,7 @@ const takeOver = (me, target) => {
 const resumed = (me, target) => {
     const session = {
         ...target, handle: me.handle, product: target.handle === me.handle ? target.product : me.product, state: 'active',
-        since: target.handle === me.handle ? target.since : stamp(), lastSeen: stamp(), pid: me.pid ?? (target.handle === me.handle ? target.pid : null),
-        takenFrom: target.handle === me.handle ? target.takenFrom : undefined
+        since: target.handle === me.handle ? target.since : stamp(), lastSeen: stamp(), pid: me.pid ?? (target.handle === me.handle ? target.pid : null)
     };
     return session;
 };

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