@idleware/ringi 0.6.1 → 0.7.0

package/target/esm/adapters/host-posix/index.js

@@ -1,35 +1,33 @@
-// host-posix: macOS/Linux process facts and launch control behind ProcessHost (core/agents/ports/host.ts). Its handles belong
-// only to this instance. A bounded observation never grants authority to stop an otherwise running process.
-import { fail } from '../../lib/fail.js';
-import { treeCpu } from './stats.js';
-import { launch } from './launch.js';
-import { alive, ancestors, snapshot, supported } from './probes.js';
-const systemClock = { wall: () => Date.now(), monotonic: () => performance.now() };
-const observe = (done, deadline, clock) => {
-    if (deadline !== undefined && !Number.isFinite(deadline))
-        fail('a process observation deadline must be finite');
-    const held = setInterval(() => { }, 1000);
-    if (deadline === undefined)
-        return done.finally(() => clearInterval(held));
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => { clearInterval(held); resolve(null); }, Math.max(0, deadline - clock.monotonic()));
-        const clear = () => { clearTimeout(timer); clearInterval(held); };
-        done.then(value => { clear(); resolve(value); }, error => { clear(); reject(error); });
-    });
+// host-posix: what macOS and Linux say about a process, and a detached start, behind ProcessHost
+// (core/agents/ports/host.ts). Elsewhere every probe says nothing rather than guess.
+import { spawn, spawnSync } from 'node:child_process';
+import path from 'node:path';
+const supported = process.platform === 'darwin' || process.platform === 'linux';
+// A process of another user that we may not signal still exists.
+const alive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
 };
-export const hostPosix = (clock = systemClock) => {
-    const processes = new WeakMap();
-    const own = (handle) => processes.get(handle) ?? fail('this process handle belongs to another host');
-    return {
-        supported, clock, alive, ancestors, snapshot,
-        inspect: (pid, rows = snapshot()) => ({ alive: supported ? alive(pid) : null, cpu: treeCpu(pid, rows) }),
-        start: request => {
-            const handle = {};
-            processes.set(handle, launch(request, clock));
-            return handle;
-        },
-        stop: handle => own(handle).stop(),
-        awaitQuiescence: (handle, deadline) => observe(own(handle).done, deadline, clock),
-    };
+// Up to twelve parents by name, from one `ps` call each; a sandbox that denies `ps` gets none.
+const ancestors = (first) => {
+    const result = [];
+    for (let pid = first, i = 0; i < 12 && pid > 1; i++) {
+        const r = spawnSync('ps', ['-o', 'ppid=,comm=', '-p', String(pid)], { encoding: 'utf8' });
+        const m = r.status === 0 ? /^\s*(\d+)\s+(.*)$/.exec(String(r.stdout ?? '').trim()) : null;
+        if (!m)
+            break;
+        result.push({ pid, name: path.basename(m[2].trim()).toLowerCase() });
+        pid = Number(m[1]);
+    }
+    return result;
 };
+export const hostPosix = () => ({
+    supported, alive, ancestors,
+    start: ({ file, args, env }) => { spawn(file, [...args], { detached: true, stdio: 'ignore', env }).unref(); },
+});
 //# sourceMappingURL=index.js.map

package/target/esm/adapters/transport-git/branches.js

@@ -1,5 +1,5 @@
 // branches: a room is one linear branch from its genesis. What its commits are (messages or control records), the
-// room's control files, and the room's life: create, archive, delete.
+// room's control files, and the room's life: create, delete.
 import { fail } from '../../lib/index.js';
 import * as Remote from './remote.js';
 import { ZERO } from './run.js';
@@ -9,17 +9,17 @@ import { ID_RE, parse } from '../../core/hub/protocol/index.js';
 const ROOT = 'operator';
 export const CONTROL_FILES = new Set(['ROOM.md', 'members.json', 'profile.json', 'allowed_signers']);
 export class Branches extends Repo {
-    ref(name) { return name.includes('@') ? `refs/archive/${name}` : `refs/heads/${name}`; }
+    ref(name) { return `refs/heads/${name}`; }
     tip(name) { return this.rev(this.ref(name)); }
     // Every branch but the contract's, by name.
     roomBranches() {
         return this.git(['for-each-ref', '--format=%(refname:lstrip=2)', 'refs/heads/']).split('\n').filter(b => b && b !== 'main');
     }
-    // Every branch but the contract's is a room; an archive is `<room>@<genesis8>`.
-    roomNames(archived) {
-        const prefix = archived ? 'refs/archive/' : 'refs/heads/';
+    // Every branch but the contract's is a room.
+    roomNames() {
+        const prefix = 'refs/heads/';
         const names = this.git(['for-each-ref', '--format=%(refname)', prefix]).split('\n').filter(Boolean).map(r => r.slice(prefix.length))
-            .filter(n => ID_RE.test(n.split('@')[0]) && n !== 'main' && n.includes('@') === archived);
+            .filter(n => ID_RE.test(n) && n !== 'main');
         return names.sort();
     }
     // A control record: the room's genesis, or a root commit of Kind: room.
@@ -42,7 +42,7 @@ export class Branches extends Repo {
     // On a signed hub the branch's verification says which commits are control records, and why the others that are no
     // valid message are skipped; a commit off the branch's first parents is never a message (remote.ts).
     judged(room, tip, entries) {
-        if (this.trust !== 'signed' || room.archived)
+        if (this.trust !== 'signed')
             return entries;
         const b = Remote.branch(this.h, { name: room.name, ref: this.ref(room.name), genesis: room.genesis }, tip);
         const control = new Set(b.control);
@@ -63,11 +63,10 @@ export class Branches extends Repo {
             return null;
         const genesis = this.git(['rev-list', '--first-parent', '--reverse', tip, '^refs/heads/main']).split('\n')[0]
             || this.git(['rev-list', '--first-parent', '--reverse', tip]).split('\n').filter(Boolean).at(-1);
-        const archived = name.includes('@');
-        if (this.trust === 'signed' && !archived && this.h.remoteAlarms?.[ref])
+        if (this.trust === 'signed' && this.h.remoteAlarms?.[ref])
             fail(`ALARM ${this.h.remoteAlarms[ref]}; room ${name} is quarantined`);
-        const control = this.entries({ name, genesis, archived }, tip).filter(e => e.control).map(e => ({ rev: e.sha, text: e.text }));
-        return { name, archived, head: control.at(-1).rev, genesis, tip, base: this.rev(`${genesis}^`) ?? ZERO, control };
+        const control = this.entries({ name, genesis }, tip).filter(e => e.control).map(e => ({ rev: e.sha, text: e.text }));
+        return { name, head: control.at(-1).rev, genesis, tip, base: this.rev(`${genesis}^`) ?? ZERO, control };
     }
     // Control files are read at a control record, never at the branch's tip.
     controlFile(room, name, rev) {
@@ -93,13 +92,7 @@ export class Branches extends Repo {
     refsUnder(prefix) {
         return this.git(['for-each-ref', '--format=%(refname) %(objectname)', prefix]).split('\n').filter(Boolean).map(l => l.split(' '));
     }
-    // The branch moves under the archive; its signals stay where they are, on its commits.
-    archiveRoom(room, as) {
-        const tip = this.rev(this.ref(room.name)) ?? fail(`room ${room.name} is gone`);
-        this.git(['update-ref', `refs/archive/${as}`, tip, ZERO]);
-        this.git(['update-ref', '-d', this.ref(room.name), tip]);
-    }
-    // Every ref of the room in one transaction: its branch (or archive), every tag on its commits (signals, heartbeats,
+    // Every ref of the room in one transaction: its branch, every tag on its commits (signals, heartbeats,
     // anyone's), what the store keeps under its genesis (pins, evidence) and its unpublished commits. Objects are left to
     // the repository.
     deleteRoom(room) {
@@ -114,10 +107,10 @@ export class Branches extends Repo {
         this.git(['update-ref', '--stdin'], { input: ['start', ...refs.map(r => `delete ${r}`), 'prepare', 'commit', ''].join('\n') });
     }
     remote(room) {
-        return { name: room.name, ref: this.ref(room.name), head: room.head, genesis: room.genesis, archived: room.archived };
+        return { name: room.name, ref: this.ref(room.name), head: room.head, genesis: room.genesis };
     }
     roster(room) {
-        if (this.trust !== 'signed' || room.archived)
+        if (this.trust !== 'signed')
             return null;
         const v = Remote.verifyRoom(this.h, this.remote(room));
         return { members: v.members, signers: v.entries };

package/target/esm/adapters/transport-git/index.js

@@ -4,7 +4,6 @@
 //                                         (the root's, on top of main); then every message is a commit by its author, and
 //                                         every control record (Kind: room) a commit by the root
 //   refs/tags/<agent>.<signal>.<message12>   signals: annotated tags without text on the message's commit
-//   refs/archive/<room>@<genesis8>        an archived room, read-only
 //   refs/ringi/accepted/<genesis>/<reader>/<author>   readers' pins of each author's accepted last message
 // A member's log is its own commits in the room's branch, in branch order. The control files at the root of a room's
 // tree (members, profile, signers) change only in the root's control records.
@@ -85,8 +84,6 @@ export class GitStore extends Marks {
     }
     // One message on top of the room's branch.
     append(room, who, text, entries) {
-        if (room.archived)
-            fail(`room ${room.name} is archived: read-only`);
         if (checkOutgoing(text, s => this.isRef(s)).trailers['ringi-files'])
             fail('Ringi-Files is store metadata; supply attachments instead');
         const own = entries.find(e => CONTROL_FILES.has(e.path));
@@ -103,8 +100,7 @@ export class GitStore extends Marks {
         return this.trust === 'signed' ? Remote.verify(this.h, this.remote(room), id, head) : null;
     }
     pin(room, reader, id, rev) {
-        if (!room.archived)
-            this.git(['update-ref', `refs/ringi/accepted/${room.genesis}/${reader}/${id}`, rev]);
+        this.git(['update-ref', `refs/ringi/accepted/${room.genesis}/${reader}/${id}`, rev]);
     }
     unpin(room, reader, id) {
         this.gitOk(['update-ref', '-d', `refs/ringi/accepted/${room.genesis}/${reader}/${id}`]);
@@ -122,7 +118,6 @@ export class GitStore extends Marks {
     joinKey(room, who) { return Remote.join(this.h, this.remote(room), who, this.home); }
     // A room's transport alarm is the room's, whichever author the operator forgets.
     forgetLog(room, _id) { Remote.forget(this.h, this.remote(room)); }
-    rootKey() { return this.d.root ?? fail(`hub ${this.d.name} has no pinned root`); }
     rootRoster() { return Remote.rootRoster(this.h); }
 }
 //# sourceMappingURL=index.js.map

package/target/esm/adapters/transport-git/marks.js

@@ -75,7 +75,7 @@ export class Marks extends Branches {
                 return [];
             return [{ ref: t.ref, object: t.object, name: t.name, actor: t.actor, target: o?.target ?? '', tagger: o?.tagger ?? '', text: o?.text ?? '' }];
         });
-        if (this.trust !== 'signed' || room.archived)
+        if (this.trust !== 'signed')
             return records;
         return Remote.withVerification(this.h, () => records.filter(s => {
             const why = Remote.verifySignal(this.h, this.remote(room), s.ref, s.object);

package/target/esm/adapters/transport-git/remote/admit.js

@@ -63,8 +63,6 @@ const admissionKey = (H, R, who, publicKey) => {
         C.fail('room admit is for signed hubs; local membership is added by join');
     if (who === ROOT)
         C.fail('the root is already pinned; root replacement requires a separate trust transition');
-    if (R.archived)
-        C.fail('cannot admit into an archived room');
     const key = keyInput(publicKey);
     return key;
 };

package/target/esm/adapters/transport-git/remote/heartbeat-push.js

@@ -5,7 +5,7 @@ import { checkHeartbeat, heartbeatRef } from './heartbeat.js';
 import { checkUrl } from './keys.js';
 import { SHA, TAG_ACCEPT, TAG_TRACK, TAGS } from './types.js';
 // Publish only the actor's exact heartbeat with an explicit old OID. A racing beat is ordinary contention, never a
-// signal rewrite alarm. Neither success nor failure changes immutable acceptance pins or budget/history state.
+// signal rewrite alarm. Neither success nor failure changes immutable acceptance pins or history state.
 export const pushHeartbeat = (H, R, who, sha, expected) => {
     const ref = heartbeatRef(who, R.genesis);
     if (!SHA.test(sha) || (expected !== null && !SHA.test(expected)))

package/target/esm/adapters/transport-git/remote/main.js

@@ -1,7 +1,7 @@
 // main: the hub's contract branch verified: every commit signed by the root since the pinned genesis.
 import * as C from '../../../lib/index.js';
 import { memo } from './cache.js';
-import { git, isRemote, rev } from './git.js';
+import { isRemote, rev } from './git.js';
 import { parseKey, rootKey } from './keys.js';
 import { blobText } from './roster.js';
 import { chain, checkSignature, linear } from './signature.js';
@@ -34,8 +34,5 @@ const checkContract = (H, sha, key) => {
     const meta = C.strictJson(blobText(H, sha, name), name);
     if (meta.schema !== 'ringi-hub' || meta.trust !== 'signed' || parseKey(meta.root).line !== key.line)
         C.fail(`${name} must declare signed trust and the pinned root key`);
-    const authority = git(H, ['cat-file', '-e', `${sha}:authority.json`], { ok: true });
-    if (authority.status === 0)
-        C.strictJson(blobText(H, sha, 'authority.json'), 'authority.json');
 };
 //# sourceMappingURL=main.js.map

package/target/esm/adapters/transport-git/repo.js

@@ -102,7 +102,6 @@ export class Repo {
         const r = this.gitOk(['show', `${rev}:${name}`]);
         return r.status === 0 ? r.stdout : null;
     }
-    contractFiles(rev) { return this.git(['ls-tree', '-r', '--name-only', rev]).split('\n').filter(Boolean); }
     amendContract(who, text, files) {
         const head = this.contractHead();
         const sha = this.commit(who, text, this.tree(`${head}^{tree}`, Object.entries(files).map(([p, c]) => ({ path: p, content: c, mode: '100644' }))), [head]);

package/target/esm/clients/cli/agent/index.js

@@ -1,9 +1,9 @@
-// agent: the commands only an agent runs, as the agent its session is bound to (`ringi agent inbox`, whoami, card,
-// ping, wait, take); joining and leaving a room are session.ts.
+// agent: the commands only an agent runs, as the agent its session is bound to (`ringi agent inbox`, whoami, wait,
+// take); joining and leaving a room are session.ts.
 import * as Agent from '../../../core/agents/sessions/agent.js';
 import { asJson, render } from '../../../core/hub/usecases/view.js';
-import { fail, short, when } from '../../../lib/index.js';
-import { dump, flag, list, opt, out, textOf } from '../args.js';
+import { fail, short } from '../../../lib/index.js';
+import { dump, flag, opt, out } from '../args.js';
 import { scopeLine, waiting } from '../shared/index.js';
 const options = (o) => ({ peek: flag(o, 'peek'), limit: opt(o, 'limit') ? Number(opt(o, 'limit')) : undefined });
 export const showInbox = ({ R, me, s }, res, o) => {
@@ -31,12 +31,6 @@ export const whoami = (a) => {
     const { session: s, profile, members } = Agent.whoami(a);
     out(`${s.agent} in ${s.hub}/${s.room} (genesis ${short(s.genesis)}, profile ${profile}), session ${s.handle}, ${s.state}\nscope: ${scopeLine(s, a.R.quorum !== null)}\nmembers: ${members.join(', ')}`);
 };
-export const card = (a, o) => out(`card ${short(Agent.card(a, textOf(o)))}`);
-export const ping = (a, o) => {
-    const r = Agent.ping(a, { to: o._[0] ?? fail('usage: ringi agent ping <id> [-m <note>] [--next <s>] [--re <msg>]'),
-        text: list(o, 'm').length ? list(o, 'm').join('\n\n') : undefined, next: opt(o, 'next') ? Number(opt(o, 'next')) : undefined, re: opt(o, 're') });
-    out(`ping ${short(r.id)} to ${r.to}${r.previous ? (r.previous.answeredAt !== null ? `; ${r.to} answered the previous one at ${when(r.previous.answeredAt)}` : `; no pong to the previous one (${short(r.previous.id)})`) : ''}`);
-};
 export const wait = async (a, o) => {
     const r = await Agent.wait(a, { ...options(o), max: opt(o, 'max') === undefined ? undefined : Number(opt(o, 'max')) });
     if (r.inbox)

package/target/esm/clients/cli/arg-parse.js

@@ -1,6 +1,6 @@
 // Parse one option at a time, keeping positional arguments and repeated values in order.
 import { fail } from '../../lib/index.js';
-const BOOLS = new Set(['task', 'peek', 'all', 'json', 'help', 'once', 'project', 'follow', 'short', 'yes', 'require-grant', 'md', 'archived', 'signed', 'repair', 'handoff', 'clear', 'published']);
+const BOOLS = new Set(['task', 'peek', 'all', 'json', 'help', 'once', 'project', 'follow', 'short', 'yes', 'md', 'signed', 'repair', 'clear', 'published']);
 const MULTI = new Set(['m', 'attach', 'set', 'drop']);
 const SHORT = { m: 'm', F: 'file', n: 'n', o: 'out', h: 'help' };
 const option = (a) => {

package/target/esm/clients/cli/commands.js

@@ -3,17 +3,16 @@
 import { about } from '../../core/hub/usecases/context.js';
 import { agent } from '../../core/agents/sessions/context.js';
 import { fail } from '../../lib/index.js';
-import { card, inbox, ping, take, wait, whoami } from './agent/index.js';
+import { inbox, take, wait, whoami } from './agent/index.js';
 import { flag, out, parseArgs } from './args.js';
 import { operatorCtx } from './context.js';
 import { helpMarkdown, helpText } from './help.js';
 import { forget, heartbeats, hub, pulse, roomCmd, sessions, where } from './operator/index.js';
 import { join, leave, resume, stop } from './agent/session.js';
-import { add, cat, decide, get, grants, log, profileCmd, proposals, propose, read, reply, send, signals, stamp_, tasks, thread, who } from './shared/index.js';
+import { add, cat, get, log, profileCmd, read, reply, send, signals, tasks, thread, who } from './shared/index.js';
 import { skill } from './skill/index.js';
-import { watchCommand } from './operator/watch.js';
-const SHARED = { add, send, reply, read, thread, tasks, log, cat, get, who, signals, profile: profileCmd, propose, stamp: stamp_, decide, proposals, grants };
-const AGENT = { ...SHARED, inbox, whoami, status: whoami, card, ping, wait, take };
+const SHARED = { add, send, reply, read, thread, tasks, log, cat, get, who, signals, profile: profileCmd };
+const AGENT = { ...SHARED, inbox, whoami, status: whoami, wait, take };
 const agentCommand = (_, rest) => {
     const [sub = 'whoami', ...more] = rest;
     const fn = AGENT[sub] ?? fail(`unknown: ringi agent ${sub}; see ringi help`);
@@ -28,10 +27,10 @@ const DIRECT = new Map([
     ['--version', version], ['-v', version], ['version', version],
     ['help', help], ['--help', help], ['-h', help], ['skill', skill], ['agent', agentCommand],
     ['hub', hub], ['room', roomCmd], ['where', where], ['sessions', sessions], ['heartbeats', heartbeats],
-    ['pulse', pulse], ['forget', forget], ['watch', watchCommand], ['join', join], ['continue', resume], ['stop', stop], ['leave', leave]
+    ['pulse', pulse], ['forget', forget], ['join', join], ['continue', resume], ['stop', stop], ['leave', leave]
 ]);
 const unknown = (cmd) => {
-    if (['inbox', 'whoami', 'ping', 'wait', 'card'].includes(cmd))
+    if (['inbox', 'whoami', 'wait', 'take'].includes(cmd))
         fail(`${cmd} is an agent command: ringi agent ${cmd}`);
     return fail(`unknown command ${cmd}; see ringi help`);
 };

package/target/esm/clients/cli/help.js

@@ -7,21 +7,16 @@ export const TABLE = [
     ['hub create <name> [--signed [--url <git url>]]', 'operator', 'another hub: asserted senders, or signed with a root key made on this machine; --url publishes it'],
     ['hub add <name> <git url> --root <public key|file> [--genesis <sha>]', 'operator', 'a replica of a signed hub; the root key comes from you, out of band, never from the hub'],
     ['hub switch <name>', 'operator', 'change the terminal\'s current hub; agents stay where they are'],
-    ['hub amend -m <subject> [--set <key>=<value>]... [--authority <file>] [--attach <file>:profiles/<name>.json]...', 'operator', 'refine the shared contract: version, capabilities, default profile, authority table, profiles'],
-    ['room list [--archived]', 'operator', 'rooms of the current hub'],
+    ['hub amend -m <subject> [--set <key>=<value>]... [--attach <file>:profiles/<name>.json]...', 'operator', 'refine the shared contract: version, capabilities, default profile, profiles'],
+    ['room list', 'operator', 'rooms of the current hub'],
     ['room create <id> [--profile <name>] [--quorum <agents>]', 'operator', 'a room for one piece of work, following a profile; becomes the current room; --quorum: its work starts by itself once that many agents joined (1: at once)'],
     ['room switch <id>', 'operator', 'change the terminal\'s current room; agents stay where they are'],
     ['room admit <agent> <public key|file>', 'operator', 'signed hubs: admit the key an agent made on its own machine'],
     ['room remove <agent>', 'operator', 'local hubs: take an agent out of the current room'],
-    ['room archive [<id>]', 'operator', 'local hubs: a room (default: the current one) is read-only from now on, wakes nobody; its sessions leave on their own'],
     ['room delete [<id>] --yes', 'operator', 'local hubs: erase a room (default: the current one) and everything kept for it; its sessions leave on their own'],
     ['room rebase-contract <id>', 'operator', 'move a room onto the hub\'s current contract'],
-    ['where [-n n] [--short] [--follow]', 'operator', 'hub, room, sessions (active, stopped, gone), open work and proposals, latest messages'],
-    ['send -m <subject> [-m <body>]... [--to <ids>] [--task] [--re <msg>] [--state <s>] [--assign <ids>] [--roles <id>=<label>,...] [--grant <decision>] [--attach <src>[:<dest>]]...', 'operator', 'a message as operator; without --to it goes to the room and wakes nobody; --task opens work of the room\'s profile'],
-    ['propose -m <subject> [-m <body>] --decider <id> [--reviewers <ids>] [--due 2h|<ISO>] [--budget runs=<n>,run-seconds=<n>,concurrency=<n>] [--supersedes <proposal>]', 'both', 'a proposal; it circulates to the reviewers and the decider'],
-    ['stamp <proposal> approve|object|abstain -m <reason>', 'both', 'a named reviewer\'s stamp on that exact revision'],
-    ['decide <proposal> approved|rejected|revoked -m <reason>', 'both', 'the named decider, with authority; an approval with a budget is a grant'],
-    ['proposals [--all] | grants', 'both', 'open proposals with their stamps; grants with their usage'],
+    ['where [-n n] [--short] [--follow]', 'operator', 'hub, room, sessions (active, stopped, gone), open work, latest messages'],
+    ['send -m <subject> [-m <body>]... [--to <ids>] [--task] [--re <msg>] [--state <s>] [--assign <ids>] [--roles <id>=<label>,...] [--attach <src>[:<dest>]]...', 'operator', 'a message as operator; without --to it goes to the room and wakes nobody; --task opens work of the room\'s profile'],
     ['add <src>[:<dest>]... | add [--drop <path>]... [--clear]', 'both', 'stage files for your next message, like git add: their content is taken now; results and state travel only as attachments'],
     ['tasks [--all] | log [-n n] | read <msg> | thread <msg> | cat <msg> [<path>] | get <msg> [-o <dir>] | who', 'both', 'reading the room (agents: ringi agent …)'],
     ['signals [--all] [--repair]', 'both', 'what happened (signals) and where attention is (read and taken marks), each checked; --repair restores your missing signals'],
@@ -30,7 +25,6 @@ export const TABLE = [
     ['heartbeats [--json] | heartbeats --published [--room <id>]', 'operator', 'each session\'s pulse on this machine, from its process and its tool\'s trace, without the model: working, waiting (for what) or gone; --published: the room\'s heartbeat tags as an orchestrator reads them'],
     ['pulse [--beat <s>] [--once]', 'operator', 'beat for every session here: sync its hub, put its heartbeat tag on the last pulled commit of its room; join and continue start it (RINGI_PULSE=off: not)'],
     ['forget <room>/<log>', 'operator', 'after a changed-history alarm: accept a new baseline for that log'],
-    ['watch [<hub>:]<room>/<agent> --exec <cmd> [--handoff] [--scope <text>] [--once] [--require-grant] [--from <ids>] [--max-hop n] [--max-runs n] [--window s] [--interval s]', 'operator', 'headless turns for one agent: answers pings, spends grants, writes usage receipts; --handoff, run from the agent\'s own chat, moves its seat and scope to the watcher; exits with the failed turn\'s status'],
     ['skill install [--project] | uninstall | status | show', 'operator', 'the skill for Claude Code, Codex and Cursor'],
     ['join <hub> <room> [--as <id>] [--scope <text>]', 'session', 'bind this chat to a room as an agent, with what the operator delegates'],
     ['continue [[<hub>:]<room>/<agent>]', 'session', 'resume this chat\'s binding, also after a restart; naming one takes over a paused or gone one'],
@@ -39,10 +33,9 @@ export const TABLE = [
     ['agent whoami', 'agent', 'identity, room, profile, scope'],
     ['agent inbox [--peek] [--limit n]', 'agent', 'what is new for you; marks it seen and leaves a read mark on each (--peek: neither)'],
     ['agent take <work>', 'agent', 'a taken mark: you are on it; others see it in tasks and read. It changes no state'],
-    ['agent send … | reply <msg> -m … [--state <s>] [--assign <ids>] [--roles …] [--grant <decision>] [--attach …] [--all]', 'agent', 'write; answer the message you act on'],
-    ['agent propose | stamp | decide | proposals | grants', 'agent', 'decisions, as the joined agent'],
+    ['agent send … | reply <msg> -m … [--state <s>] [--assign <ids>] [--roles …] [--attach …] [--all]', 'agent', 'write; answer the message you act on'],
     ['agent tasks | log | read | thread | cat | get | who | signals | profile', 'agent', 'reading, as the joined agent'],
-    ['agent ping <id> [-m <note>] [--next <s>] | agent wait [--max <s>] | agent card -m <text>', 'agent', 'heartbeats; hold the line only when the operator asks; who you are'],
+    ['agent wait [--max <s>]', 'agent', 'hold the line only when the operator asks'],
 ];
 export const helpText = () => {
     const groups = [['operator', 'operator: in a terminal, in the current hub and room'], ['session', 'session: in a chat, on the operator\'s words'], ['agent', 'agent: during a turn, in the session\'s own room'], ['both', 'operator in a terminal, or an agent as ringi agent …']];

package/target/esm/clients/cli/operator/heartbeat-format.js

@@ -3,6 +3,6 @@ import { short } from '../../../lib/index.js';
 export const publishedLine = (h) => `${h.agent.padEnd(12)} ${(h.waits ? `${h.state} (${h.waits})` : h.state).padEnd(22)} ${h.age}s ago${h.overdue ? ', overdue' : ''}  on ${short(h.target)}`;
 export const pulseLine = ({ session: s, tool, beat: b }) => {
     const state = b.waits ? `${b.state} (${b.waits})` : b.state;
-    return `${s.agent.padEnd(12)} ${`${s.hub}/${s.room}`.padEnd(24)} ${state.padEnd(22)} alive ${b.alive === null ? '?' : b.alive ? 'yes' : 'no'}  quiet ${b.quiet}s${b.cpu === null ? '' : `  cpu ${b.cpu.toFixed(1)}s`}  ${tool}  ${s.handle}`;
+    return `${s.agent.padEnd(12)} ${`${s.hub}/${s.room}`.padEnd(24)} ${state.padEnd(22)} alive ${b.alive === null ? '?' : b.alive ? 'yes' : 'no'}  quiet ${b.quiet}s  ${tool}  ${s.handle}`;
 };
 //# sourceMappingURL=heartbeat-format.js.map

package/target/esm/clients/cli/operator/hub-commands.js

@@ -31,7 +31,7 @@ export const addHub = (o) => {
 export const amendHub = (o) => {
     const H = Hubs.hubOf(opt(o, 'hub'));
     const files = list(o, 'attach').flatMap(attachments).map(e => ({ path: e.path, content: fs.readFileSync(e.file) }));
-    const r = Hubs.amend(H, { text: textOf(o), set: list(o, 'set'), authority: opt(o, 'authority'), files });
+    const r = Hubs.amend(H, { text: textOf(o), set: list(o, 'set'), files });
     return out(`amended hub ${H.name}: contract ${r.version}; rooms keep their base until ringi room rebase-contract <room>`);
 };
 //# sourceMappingURL=hub-commands.js.map

package/target/esm/clients/cli/operator/index.js

@@ -1,5 +1,5 @@
 // operator: the commands only the operator runs, as the operator of this machine in its terminal context: hubs, rooms,
-// where things stand, sessions, heartbeats, the pulse and the watcher.
+// where things stand, sessions, heartbeats and the pulse.
 export { heartbeats, pulse } from './heartbeat.js';
 export { hub } from './hub.js';
 export { roomCmd } from './room.js';

package/target/esm/clients/cli/operator/room.js

@@ -1,11 +1,50 @@
-// room: `ringi room <subcommand>`, by its table (room-list, room-members, room-lifecycle).
+// room: `ringi room list | create | switch | admit | remove | delete | rebase-contract`.
+import { roomsActive } from '../../../core/agents/overview.js';
 import * as Hubs from '../../../core/hub/usecases/hubs.js';
-import { fail } from '../../../lib/index.js';
-import { opt } from '../args.js';
-import { archiveRoom, deleteRoom, rebaseRoomContract } from './room-lifecycle.js';
-import { createRoom, listRoom, switchRoom } from './room-list.js';
-import { admitRoom, removeRoom } from './room-members.js';
-const COMMANDS = new Map([['list', listRoom], ['create', createRoom], ['switch', switchRoom], ['admit', admitRoom], ['remove', removeRoom], ['archive', archiveRoom], ['delete', deleteRoom], ['rebase-contract', rebaseRoomContract]]);
+import * as Rooms from '../../../core/hub/usecases/rooms.js';
+import { fail, short } from '../../../lib/index.js';
+import { flag, opt, out } from '../args.js';
+const list = H => {
+    const rs = roomsActive(H);
+    for (const r of rs)
+        out(`${r.current ? '*' : ' '} ${r.name.padEnd(16)} ${r.members} member(s), ${r.active} active session(s), profile ${r.profile}  genesis ${short(r.genesis)}`);
+    if (!rs.length)
+        out(`no rooms in hub ${H.name}: ringi room create <id>`);
+};
+const create = (H, arg, o) => {
+    const quorum = opt(o, 'quorum');
+    const r = Rooms.create(H, arg ?? '', { profile: opt(o, 'profile'), quorum: quorum === undefined ? undefined : Number(quorum) });
+    const start = quorum === undefined ? '' : ` Its work starts by itself at a quorum of ${quorum} agent(s).`;
+    out(`created room ${arg} in hub ${H.name} with profile ${r.profile}; it is the current room.${start} In each chat that should take part, say "join ${arg} as <id>"`);
+};
+const use = (H, arg) => {
+    const R = Rooms.use(H, arg ?? fail('usage: ringi room switch <id>'));
+    out(`current room: ${H.name}/${R.name}; agents keep their own rooms`);
+};
+const admit = (H, arg, o) => {
+    const R = Rooms.roomIn(H, opt(o, 'room'));
+    Rooms.admit(H, R, arg ?? fail('usage: ringi room admit <agent> <public key|file>'), o._[2] ?? fail('usage: ringi room admit <agent> <public key|file>'));
+    out(`admitted ${arg} to ${H.name}/${R.name}: its signed messages are accepted from now on; it can join`);
+};
+const remove = (H, arg, o) => {
+    const R = Rooms.roomIn(H, opt(o, 'room'));
+    Rooms.remove(H, R, arg ?? fail('usage: ringi room remove <agent>'));
+    out(`removed ${arg} from ${R.name}: it can no longer write or be woken there; returning needs a fresh join`);
+};
+// Without an id, the room of the current context.
+const erase = (H, arg, o) => {
+    const R = Rooms.roomIn(H, arg ?? opt(o, 'room'));
+    if (!flag(o, 'yes'))
+        fail(`deleting ${R.name} in hub ${H.name} erases it and everything kept for it, for good. Run again with --yes`);
+    Rooms.erase(H, R);
+    out(`deleted room ${R.name}: its branch, signals, pins, evidence and readers' state. Sessions bound to it leave it on their next turn`);
+};
+const rebase = (H, arg) => {
+    const R = Rooms.roomIn(H, arg ?? fail('usage: ringi room rebase-contract <id>'));
+    Rooms.rebase(H, R);
+    out(`room ${R.name} now follows the hub contract at ${short(H.main)} (${H.contract.version})`);
+};
+const COMMANDS = new Map([['list', list], ['create', create], ['switch', use], ['admit', admit], ['remove', remove], ['delete', erase], ['rebase-contract', rebase]]);
 export const roomCmd = (o) => {
     const [sub, arg] = o._;
     const H = Hubs.hubOf(opt(o, 'hub'));

package/target/esm/clients/cli/operator/where-format.js

@@ -12,13 +12,11 @@ const quorumLine = (R) => {
     const agents = Object.values(R.members).filter(m => m.role !== 'root').length;
     return agents >= R.quorum ? `; started at its quorum of ${R.quorum} agents` : `; waiting for a quorum of ${R.quorum} agents, has ${agents}`;
 };
-const roomLine = (R) => `room ${R.name}${R.archived ? ' (archived, read-only)' : ''}, genesis ${short(R.genesis)}, profile ${R.profile.name}; members: ${Object.entries(R.members).map(([id, i]) => i.role === 'root' ? `${id} (root)` : id).join(', ')}` + quorumLine(R);
+const roomLine = (R) => `room ${R.name}, genesis ${short(R.genesis)}, profile ${R.profile.name}; members: ${Object.entries(R.members).map(([id, i]) => i.role === 'root' ? `${id} (root)` : id).join(', ')}` + quorumLine(R);
 export const printOverview = (w, R) => {
     out(roomLine(R));
     out(w.sessions.length ? `sessions:\n${w.sessions.map(s => `  ${sessionLine(s)}`).join('\n')}` : 'sessions: none joined');
     out(w.work.length ? `open work:\n${w.work.map(t => `  ${taskLine(t)}`).join('\n')}` : 'open work: none');
-    if (w.proposals.length)
-        out(`open proposals:\n${w.proposals.map(x => `  ${short(x.proposal.id)} ${x.state} → ${x.decider}  ${x.proposal.subject}`).join('\n')}`);
 };
 export const showMessage = (R, o, all, m) => out(flag(o, 'short') ? `  ${oneLine(m)}` : `\n${render(all, m, { max: 2000, files: () => withSizes(R, m) })}`);
 //# sourceMappingURL=where-format.js.map

package/target/esm/clients/cli/shared/index.js

@@ -1,6 +1,5 @@
 // shared: the commands both run: `ringi send` acts as the operator, `ringi agent send` as the agent its session is
-// bound to; messages, files, work, signals, proposals and grants.
-export { decide, grants, proposals, propose, stamp_ } from './budget.js';
+// bound to; messages, files, work and signals.
 export { cat, get } from './files.js';
 export { add, read, reply, send, thread } from './messages.js';
 export { profileCmd, who } from './profile.js';

package/target/esm/clients/cli/shared/messages.js

@@ -6,7 +6,7 @@ import { bytes, fail, short, 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'),
+    state: opt(o, 'state'), assign: opt(o, 'assign') ? words(opt(o, 'assign')) : undefined, roles: opt(o, 'roles'),
     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)` : ''}`);

package/target/esm/clients/cli/shared/profile.js

@@ -1,4 +1,4 @@
-// profile: `profile` (what work is in the room) and `who` (its members and their cards).
+// profile: `profile` (what work is in the room) and `who` (its members).
 import * as Room from '../../../core/hub/usecases/room.js';
 import { dump, flag, out } from '../args.js';
 export const profileCmd = ({ R }, o) => {
@@ -12,6 +12,6 @@ export const profileCmd = ({ R }, o) => {
 };
 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}` : ''}`);
+        out(`${x.id.padEnd(12)} ${x.role.padEnd(7)} ${String(x.messages).padStart(4)} msg`);
 };
 //# sourceMappingURL=profile.js.map

package/target/esm/clients/cli/shared/work.js

@@ -5,7 +5,7 @@ import { short, when } from '../../../lib/index.js';
 import { dump, flag, opt, out } from '../args.js';
 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}`;
+    return `${short(t.id)}  ${t.state.padEnd(14)} ${t.requester} → ${t.assignees.join(',') || '(open)'}${roles}${t.taken.length ? ` taken by ${t.taken.join(',')}` : ''}  ${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') });

package/target/esm/composition/index.js

@@ -15,8 +15,6 @@ import { cursor } from '../adapters/tool-cursor/index.js';
 import { hostPosix } from '../adapters/host-posix/index.js';
 import { keysFile } from '../adapters/keys-file/index.js';
 import { gitTransport } from '../adapters/transport-git/transport.js';
-import { kafka } from '../adapters/transport-kafka/index.js';
-import { temporal } from '../adapters/transport-temporal/index.js';
 // The package this file belongs to, run from its source (src/main/ts) or its build (target/esm).
 const packageOf = (dir) => fs.existsSync(path.join(dir, 'package.json')) ? dir : packageOf(path.dirname(dir));
 const PACKAGE = packageOf(path.dirname(fileURLToPath(import.meta.url)));
@@ -26,7 +24,7 @@ export const build = {
 };
 const root = path.resolve(process.env.RINGI_HOME || path.join(os.homedir(), '.ringi'));
 // The git store signs with keys kept as files under the home, made only for a signed hub.
-const transports = { git: gitTransport(root, { signer: () => keysFile(root) }), kafka, temporal };
+const transports = { git: gitTransport(root, { signer: () => keysFile(root) }) };
 wireHub({ build, state: stateFs({ root, build }), transports, store: 'git' });
 // In the order a session is recognised by.
 wireAgents({ tools: [claude, codex, cursor], host: hostPosix() });