@idleware/ringi 0.7.2 → 0.8.1

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

@@ -8,8 +8,8 @@ import { scopeLine, taskLine, waiting } from '../shared/index.js';
 export const briefing = (s) => {
     const r = Session.briefing(s);
     const auto = r.start.quorum !== null;
-    out(`${s.agent} in ${s.hub}/${s.room}; scope: ${scopeLine(s, auto)}`);
-    out('agent commands: ringi agent inbox | reply <id> … | send … | tasks | proposals | whoami. A turn: inbox, your part, replies, end the turn. Never block on a peer.');
+    out(`${s.agent} in ${s.room}; scope: ${scopeLine(s, auto)}`);
+    out('agent commands: ringi agent inbox | reply <id> … | send … | tasks | whoami. A turn: inbox, your part, replies, end the turn. Never block on a peer.');
     if (!r.start.started)
         return out(waiting(s.room, r.start));
     if (auto)
@@ -21,16 +21,16 @@ export const briefing = (s) => {
     showInbox(r.actor, r.inbox, { _: [] });
 };
 export const join = (o) => {
-    const [hub, room] = o._;
-    if (!hub || !room)
-        fail('usage: ringi join <hub> <room> [--as <id>] [--scope "<what the operator delegates>"]');
-    const r = Session.join({ hub, room, agent: opt(o, 'as'), scope: opt(o, 'scope') });
+    const [room] = o._;
+    if (!room)
+        fail('usage: ringi join <room or its invitation> [--as <id>] [--scope "<what the operator delegates>"]');
+    const r = Session.join({ room, agent: opt(o, 'as'), scope: opt(o, 'scope') });
     if (r.key) {
-        out(`${r.agent}'s key on this machine (${r.key.fingerprint}). Ask the root to admit it, then join again:\n  ringi room admit ${r.agent} '${r.key.publicKey}' --hub ${r.hub} --room ${r.room}`);
+        out(`${r.agent}'s key on this machine (${r.key.fingerprint}). Ask the root to admit it, then join again:\n  ringi room admit ${r.agent} '${r.key.publicKey}' --room ${r.room}`);
         process.exitCode = 3;
         return;
     }
-    out(`joined ${r.hub}/${r.room} as ${r.agent}`);
+    out(`joined ${r.room} as ${r.agent}`);
     Heartbeat.ensurePulse(process.argv[1]);
     briefing(r.session);
 };
@@ -41,10 +41,10 @@ export const resume = (o) => {
 };
 export const stop = () => {
     const s = Session.stop();
-    out(`stopped: ${s.agent} keeps its seat in ${s.hub}/${s.room} and reacts to nothing until the operator says "continue"`);
+    out(`stopped: ${s.agent} keeps its seat in ${s.room} and reacts to nothing until the operator says "continue"`);
 };
 export const leave = () => {
     const s = Session.leave();
-    out(`left ${s.hub}/${s.room}: the seat of ${s.agent} is free; ${s.agent} stays a member until the operator removes it`);
+    out(`left ${s.room}: the seat of ${s.agent} is free; ${s.agent} stays a member until the operator removes it`);
 };
 //# sourceMappingURL=session.js.map

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

@@ -7,12 +7,12 @@ 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 { forget, heartbeats, hub, pulse, roomCmd, where } from './operator/index.js';
 import { join, leave, resume, stop } from './agent/session.js';
-import { add, cat, get, log, profileCmd, read, reply, send, signals, tasks, thread, who } from './shared/index.js';
+import { cat, get, log, profileCmd, read, reply, send, signals, tasks, thread } from './shared/index.js';
 import { skill } from './skill/index.js';
-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 SHARED = { send, reply, read, thread, tasks, log, cat, get, signals, profile: profileCmd };
+const AGENT = { ...SHARED, inbox, whoami, wait, take };
 const agentCommand = (_, rest) => {
     const [sub = 'whoami', ...more] = rest;
     const fn = AGENT[sub] ?? fail(`unknown: ringi agent ${sub}; see ringi help`);
@@ -26,7 +26,7 @@ const help = (o) => flag(o, 'md') ? void process.stdout.write(helpMarkdown()) :
 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],
+    ['hub', hub], ['room', roomCmd], ['where', where], ['heartbeats', heartbeats],
     ['pulse', pulse], ['forget', forget], ['join', join], ['continue', resume], ['stop', stop], ['leave', leave]
 ]);
 const unknown = (cmd) => {

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

@@ -2,5 +2,5 @@
 import * as Context from '../../core/hub/usecases/context.js';
 import { opt } from './args.js';
 export { isRef } from '../../core/hub/usecases/room.js';
-export const operatorCtx = (o) => Context.operator({ hub: opt(o, 'hub'), room: opt(o, 'room') });
+export const operatorCtx = (o) => Context.operator({ room: opt(o, 'room') });
 //# sourceMappingURL=context.js.map

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

@@ -3,42 +3,36 @@ import { about } from '../../core/hub/usecases/context.js';
 // --- commands ---
 // [command, who runs it, what it does]: the one table behind `ringi help` and COMMANDS.md.
 export const TABLE = [
-    ['hub [list]', 'operator', 'the hubs; `local` exists by default; * marks the current one'],
-    ['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>]... [--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)'],
+    ['hub [list]', 'operator', 'the hubs; `local` exists by default'],
+    ['hub create <name> [--signed [--url <address>]]', 'operator', 'another hub: asserted senders, or signed with a root key made on this machine; --url publishes its contract (an address names its store: git+ssh://…, git+https://…, git+file://…)'],
+    ['hub amend [--hub <name>] -m <subject> [--set <key>=<value>]... [--attach <file>:profiles/<name>.json]...', 'operator', 'refine the shared contract (of hub local unless named): version, capabilities, default profile, profiles; rooms made from then on follow it'],
+    ['room list', 'operator', 'the rooms on this machine; a room\'s name is unique here, whatever hub keeps it'],
+    ['room create <id> [--hub <name>] [--profile <name>] [--quorum <agents>] [--url <address>]', 'operator', 'a room for one piece of work, in its own repository (in hub local unless named), following a profile; becomes the current room; --quorum: its work starts by itself once that many agents joined (1: at once); --url: a signed hub publishes the room there and prints the join line for agents elsewhere'],
     ['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 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, latest messages'],
+    ['room delete [<id>] --yes', 'operator', 'erase a room\'s store on this machine (default: the current room) and everything kept for it; its sessions leave on their own'],
+    ['where [-n n] [--short] [--follow]', 'operator', 'the room, its hub and contract, 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 …)'],
+    ['tasks [--all] | log [-n n] | read <msg> | thread <msg> | cat <msg> [<path>] | get <msg> [-o <dir>]', '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'],
     ['profile', 'both', 'the room\'s profile: what a piece of work is, its states, who may move it'],
-    ['sessions | sessions forget <handle>', 'operator', 'the chats the CLI remembers; drop a stale one'],
-    ['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)'],
+    ['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 telemetry as an orchestrator reads it'],
+    ['pulse [--beat <s>] [--once]', 'operator', 'beat for every session here: sync its room, append its telemetry, naming the last pulled message 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'],
-    ['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'],
+    ['skill install | uninstall', 'operator', 'the skill for Claude Code, Codex and Cursor'],
+    ['join <room> [--as <id>] [--scope <text>]', 'session', 'bind this chat to a room as an agent, with what the operator delegates; <room>: its name on this machine, or the operator\'s invitation (ringi:…) to one elsewhere'],
+    ['continue [<room>/<agent>]', 'session', 'resume this chat\'s binding, also after a restart; naming one takes over a paused or gone one'],
     ['stop', 'session', 'pause: keep the seat, react to nothing'],
     ['leave', 'session', 'release the seat'],
     ['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 …] [--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 tasks | log | read | thread | cat | get | signals | profile', 'agent', 'reading, as the joined agent'],
     ['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 …']];
+    const groups = [['operator', 'operator: in a terminal, in the current 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 …']];
     const width = 56;
     const line = ([cmd, , what]) => cmd.length > width ? `  ringi ${cmd}\n  ${' '.repeat(width + 6)} ${what}` : `  ringi ${cmd.padEnd(width)} ${what}`;
     return [`ringi ${about().version}: distributed agent coordinator. Home: ${about().home} (RINGI_HOME).`,

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  ${tool}  ${s.handle}`;
+    return `${s.agent.padEnd(12)} ${`${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/heartbeat.js

@@ -1,11 +1,10 @@
 // heartbeat: `ringi heartbeats` (this machine's sessions, or what a room publishes) and `ringi pulse`.
 import * as Heartbeat from '../../../core/agents/heartbeat/pulse.js';
-import * as Hubs from '../../../core/hub/usecases/hubs.js';
 import * as Rooms from '../../../core/hub/usecases/rooms.js';
 import { dump, flag, opt, out } from '../args.js';
 import { publishedLine, pulseLine } from './heartbeat-format.js';
 const published = (o) => {
-    const R = Rooms.roomIn(Hubs.hubOf(opt(o, 'hub')), opt(o, 'room'));
+    const R = Rooms.roomNamed(opt(o, 'room'));
     const hs = Heartbeat.published(R);
     if (flag(o, 'json'))
         return dump(hs);

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

@@ -1,37 +1,24 @@
-// hub-commands: `ringi hub list | create | switch | add | amend`.
+// hub-commands: `ringi hub list | create | amend`.
 import fs from 'node:fs';
 import * as Hubs from '../../../core/hub/usecases/hubs.js';
-import * as Rooms from '../../../core/hub/usecases/rooms.js';
-import { fail } from '../../../lib/index.js';
 import { attachments, flag, list, opt, out, textOf } from '../args.js';
 export const listHub = (_) => {
     for (const h of Hubs.hubs())
-        out(`${h.current ? '*' : ' '} ${h.name.padEnd(12)} ${h.store}, ${h.trust}, contract ${h.contract}, ${h.rooms} room(s)${h.remote ? `  remote ${h.remote}` : ''}  ${h.dir}`);
+        out(`${h.name.padEnd(12)} ${h.store}, ${h.trust}, ${h.contract ? `contract ${h.contract}` : 'contract only in its rooms'}, ${h.rooms} room(s)${h.remote ? `  remote ${h.remote}` : ''}  ${h.dir}`);
     return;
 };
 export const createHub = (o) => {
     const [, arg] = o._;
     const r = Hubs.create(arg ?? '', { signed: flag(o, 'signed'), url: opt(o, 'url') });
-    if (!r.add)
+    if (!r.H.signed)
         return out(`created hub ${arg} (${r.H.dir})`);
-    return out(`created signed hub ${arg}${r.remote ? `, published to ${r.remote}` : ''}. Its root key stays on this machine (${r.rootKey}).
-Give every machine that joins it, out of band:
-  ${r.add}`);
-};
-export const switchHub = (o) => {
-    const [, arg] = o._;
-    Hubs.use(arg ?? fail('usage: ringi hub switch <name>'));
-    return out(`current hub: ${arg}; agents keep their own rooms`);
-};
-export const addHub = (o) => {
-    const [, arg] = o._;
-    const H = Hubs.add(arg ?? '', o._[2] ?? '', { root: opt(o, 'root'), genesis: opt(o, 'genesis') });
-    return out(`added signed hub ${arg} from ${o._[2]}: contract ${H.contract.version}, ${Rooms.rooms(H).length} room(s), root pinned`);
+    return out(`created signed hub ${arg}${r.remote ? `, its contract published to ${r.remote}` : ''}. Its root key stays on this machine (${r.rootKey}).
+A room made with --url prints the invitation its agents join by, elsewhere.`);
 };
 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'), files });
-    return out(`amended hub ${H.name}: contract ${r.version}; rooms keep their base until ringi room rebase-contract <room>`);
+    return out(`amended hub ${H.name}: contract ${r.version}; rooms made from now on follow it, existing ones keep the contract they were made with`);
 };
 //# sourceMappingURL=hub-commands.js.map

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

@@ -1,7 +1,7 @@
 // hub: `ringi hub <subcommand>`, by its table (hub-commands.ts).
 import { fail } from '../../../lib/index.js';
-import { addHub, amendHub, createHub, listHub, switchHub } from './hub-commands.js';
-const COMMANDS = new Map([['list', listHub], ['create', createHub], ['switch', switchHub], ['add', addHub], ['amend', amendHub]]);
+import { amendHub, createHub, listHub } from './hub-commands.js';
+const COMMANDS = new Map([['list', listHub], ['create', createHub], ['amend', amendHub]]);
 export const hub = (o) => {
     const [sub] = o._;
     const run = COMMANDS.get(sub || 'list') ?? fail(`unknown: hub ${sub}`);

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

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

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

@@ -1,54 +1,47 @@
-// room: `ringi room list | create | switch | admit | remove | delete | rebase-contract`.
+// room: `ringi room list | create | switch | admit | delete`, the rooms of this machine by name, whatever hub keeps them.
 import { roomsActive } from '../../../core/agents/overview.js';
 import * as Hubs from '../../../core/hub/usecases/hubs.js';
 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);
+const list = () => {
+    const rs = roomsActive();
     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)}`);
+        out(`${r.current ? '*' : ' '} ${r.name.padEnd(16)} ${r.members} member(s), ${r.active} active session(s), profile ${r.profile}, hub ${r.hub}  genesis ${short(r.genesis)}`);
     if (!rs.length)
-        out(`no rooms in hub ${H.name}: ringi room create <id>`);
+        out('no rooms on this machine: ringi room create <id>');
 };
-const create = (H, arg, o) => {
+// In hub `local` unless --hub names another.
+const create = (arg, o) => {
+    const H = Hubs.hubOf(opt(o, 'hub'));
     const quorum = opt(o, 'quorum');
-    const r = Rooms.create(H, arg ?? '', { profile: opt(o, 'profile'), quorum: quorum === undefined ? undefined : Number(quorum) });
+    const r = Rooms.create(H, arg ?? '', { profile: opt(o, 'profile'), quorum: quorum === undefined ? undefined : Number(quorum), url: opt(o, 'url') });
     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>"`);
+    if (r.join)
+        out(`Its invitation: in an agent's chat on another machine, the operator says "join <invitation> as <id>", which runs:\n  ${r.join}`);
 };
-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 use = arg => {
+    const R = Rooms.use(arg ?? fail('usage: ringi room switch <id>'));
+    out(`current room: ${R.name}; agents keep their own rooms`);
 };
-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`);
+const admit = (arg, o) => {
+    const R = Rooms.roomNamed(opt(o, 'room'));
+    Rooms.admit(R.hub, 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 ${R.name}: its signed messages are accepted from now on; it can join`);
 };
 // Without an id, the room of the current context.
-const erase = (H, arg, o) => {
-    const R = Rooms.roomIn(H, arg ?? opt(o, 'room'));
+const erase = (arg, o) => {
+    const R = Rooms.roomNamed(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`);
+        fail(`deleting ${R.name} erases its store on this machine and everything kept for it, for good. Run again with --yes`);
+    Rooms.erase(R);
+    out(`deleted room ${R.name}: its repository, signals, pins, evidence and readers' state on this machine. 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]]);
+const COMMANDS = new Map([['list', list], ['create', create], ['switch', use], ['admit', admit], ['delete', erase]]);
 export const roomCmd = (o) => {
     const [sub, arg] = o._;
-    const H = Hubs.hubOf(opt(o, 'hub'));
     const run = COMMANDS.get(sub || 'list') ?? fail(`unknown: room ${sub}`);
-    run(H, arg, o);
+    run(arg, o);
 };
 //# sourceMappingURL=room.js.map

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

@@ -1,32 +1,14 @@
-// sessions: `ringi sessions` (the seats this machine holds; `forget <handle>` frees one) and `ringi forget <room>/<log>`
-// (a new baseline for a log after an alarm).
-import * as Hubs from '../../../core/hub/usecases/hubs.js';
-import * as Overview from '../../../core/agents/overview.js';
+// sessions: how a session shows in where, and `ringi forget <room>/<log>` (a new baseline for a log after an alarm).
 import * as Rooms from '../../../core/hub/usecases/rooms.js';
 import { fail } from '../../../lib/index.js';
-import { dump, flag, opt, out } from '../args.js';
-// --- where things stand, sessions, forget ---
+import { out } from '../args.js';
 export const sessionLine = (s) => `${s.agent.padEnd(12)} ${s.liveness.padEnd(8)} ${(s.product ?? '?').padEnd(7)} ${s.handle}${s.scope ? `  scope: ${s.scope}` : ''}`;
-export const sessions = (o) => {
-    if (o._[0] === 'forget') {
-        const handle = o._[1] ?? fail('usage: ringi sessions forget <handle>');
-        Overview.forgetSession(handle);
-        return out(`forgot session ${handle}; its seat is free`);
-    }
-    const ss = Overview.sessions();
-    if (flag(o, 'json'))
-        return dump(ss);
-    if (!ss.length)
-        return out('no sessions');
-    for (const s of ss)
-        out(`${s.hub}/${s.room}  ${sessionLine(s)}`);
-};
 export const forget = (o) => {
     const [name, id] = (o._[0] ?? '').split('/');
     if (!name || !id)
         fail('usage: ringi forget <room>/<log>');
-    const H = Hubs.hubOf(opt(o, 'hub'));
-    const n = Rooms.forgetLog(H, Rooms.roomIn(H, name), id);
+    const R = Rooms.roomNamed(name);
+    const n = Rooms.forgetLog(R.hub, R, id);
     out(`forgot the accepted history of ${name}/${id} for ${n} reader(s); the next read accepts what is there now`);
 };
 //# sourceMappingURL=sessions.js.map

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

@@ -5,7 +5,8 @@ import { short } from '../../../lib/index.js';
 import { flag, out } from '../args.js';
 import { taskLine } from '../shared/index.js';
 import { sessionLine } from './sessions.js';
-export const hubLine = (H) => `hub ${H.name}: ${H.d.store.type} store, ${H.contract.trust} senders, contract ${H.contract.version}, protocol ${H.contract.protocol}${H.contract.capabilities?.length ? `, ${H.contract.capabilities.join(' ')}` : ''}`;
+// The room's hub and the contract the room follows: a room carries its own copy (hub-2).
+export const hubLine = (R) => `hub ${R.hub.name}: ${R.hub.d.store.type} store, ${R.hub.d.trust} senders, contract ${R.contract.version}, protocol ${R.contract.protocol}${R.contract.capabilities?.length ? `, ${R.contract.capabilities.join(' ')}` : ''}`;
 const quorumLine = (R) => {
     if (R.quorum === null)
         return '';

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

@@ -1,32 +1,30 @@
 // where: `ringi where`, where things stand for the operator, and `--follow` for what lands next.
 import { config } from '../../../core/hub/usecases/context.js';
-import * as Hubs from '../../../core/hub/usecases/hubs.js';
 import * as Overview from '../../../core/agents/overview.js';
 import { sleep } from '../../../lib/index.js';
 import { flag, opt, out } from '../args.js';
 import { hubLine, printOverview, showMessage } from './where-format.js';
-const follow = async (H, R, o, seen) => {
+const follow = async (R, o, seen) => {
     out('following; new messages appear as they land (Ctrl-C to stop)');
     for (;;) {
         await sleep(Number(opt(o, 'interval') ?? 2) * 1000);
-        const now = Overview.arrived(H, R, seen);
+        const now = Overview.arrived(R, seen);
         for (const m of now.messages)
             showMessage(R, o, now.all, m);
     }
 };
 export const where = async (o) => {
-    const H = Hubs.hubOf(opt(o, 'hub'));
-    const w = Overview.where(H, opt(o, 'room') ?? config().room);
-    out(hubLine(H));
+    const w = Overview.where(opt(o, 'room') ?? config().room);
     const R = w.room;
     if (!R)
         return out('no current room: ringi room create <id> | ringi room switch <id>');
+    out(hubLine(R));
     printOverview(w, R);
     const n = Number(opt(o, 'n') ?? (flag(o, 'short') ? 10 : 5));
     out(`last ${Math.min(n, w.messages.length)} of ${w.messages.length} messages:`);
     for (const m of w.messages.slice(-n))
         showMessage(R, o, w.all, m);
     if (flag(o, 'follow'))
-        await follow(H, R, o, new Set(w.all.keys()));
+        await follow(R, o, new Set(w.all.keys()));
 };
 //# sourceMappingURL=where.js.map

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

@@ -1,8 +1,8 @@
 // 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 and signals.
 export { cat, get } from './files.js';
-export { add, read, reply, send, thread } from './messages.js';
-export { profileCmd, who } from './profile.js';
+export { read, reply, send, thread } from './messages.js';
+export { profileCmd } from './profile.js';
 export { scopeLine, waiting } from './session.js';
 export { signals } from './signals.js';
 export { log, taskLine, tasks } from './work.js';

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

@@ -1,8 +1,8 @@
-// messages: `add` (staging), `send`, `reply`, `read`, `thread`.
+// messages: `send`, `reply`, `read`, `thread`.
 import * as Room from '../../../core/hub/usecases/room.js';
 import { withSizes } from '../../../core/hub/usecases/room.js';
 import { asJson, render } from '../../../core/hub/usecases/view.js';
-import { bytes, fail, short, words } from '../../../lib/index.js';
+import { 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'),
@@ -10,16 +10,6 @@ const sendInput = (o) => ({
     files: list(o, 'attach').flatMap(attachments)
 });
 const sent = (r) => out(`sent ${short(r.id)} to ${r.to.join(', ')}${r.files ? ` with ${r.files} file(s)` : ''}`);
-// Stages files for the actor's next message, like git add: their content is taken into the hub now. Without files it
-// lists what is staged; --drop <path> and --clear take files back out.
-export const add = (a, o) => {
-    if (flag(o, 'clear'))
-        Room.unstage(a, null);
-    else if (list(o, 'drop').length)
-        Room.unstage(a, list(o, 'drop'));
-    const staged = o._.length ? Room.stage(a, o._.flatMap(attachments)) : Room.staged(a);
-    out(staged.length ? `staged for your next message:\n${staged.map(s => `  ${s.path} (${bytes(s.size)})`).join('\n')}` : 'nothing staged');
-};
 export const send = (a, o) => sent(Room.send(a, { ...sendInput(o), re: opt(o, 're') }));
 export const reply = (a, o) => sent(Room.send(a, { ...sendInput(o), re: o._[0] ?? fail('usage: reply <msg> -m <text> …'), reply: true }));
 export const read = (a, o) => {

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

@@ -1,5 +1,4 @@
-// profile: `profile` (what work is in the room) and `who` (its members).
-import * as Room from '../../../core/hub/usecases/room.js';
+// profile: `profile`, what work is in the room.
 import { dump, flag, out } from '../args.js';
 export const profileCmd = ({ R }, o) => {
     if (flag(o, 'json'))
@@ -10,8 +9,4 @@ export const profileCmd = ({ R }, o) => {
     for (const [k, v] of Object.entries(P.rules))
         out(`  ${k.padEnd(18)} ${(v ?? []).join(', ')}`);
 };
-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`);
-};
 //# sourceMappingURL=profile.js.map

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

@@ -1,15 +1,17 @@
 // skill: the agents' manual for this same command line (src/main/resources/skill/), installed where each agent tool
-// reads skills (targets.ts), checked and removed again.
+// reads skills, and removed again.
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { about } from '../../../core/hub/usecases/context.js';
-import { sandboxHints } from '../../../core/agents/sessions/context.js';
+import { sandboxHints, skillDirs } from '../../../core/agents/sessions/context.js';
 import { fail } from '../../../lib/index.js';
-import { flag, out } from '../args.js';
-import { SKILL, sameSkill, skillTargets } from './targets.js';
-export { SKILL, skillTargets } from './targets.js';
-const install = (o) => {
-    for (const dir of skillTargets(flag(o, 'project'))) {
+import { out } from '../args.js';
+export const SKILL = path.join(about().resources, 'skill', 'ringi');
+// Each agent tool's skill directory under the user's home; nothing is written into projects.
+export const skillTargets = () => skillDirs(os.homedir());
+const install = () => {
+    for (const dir of skillTargets()) {
         fs.mkdirSync(dir, { recursive: true });
         fs.cpSync(SKILL, dir, { recursive: true });
         out(`installed ${dir}`);
@@ -17,24 +19,17 @@ const install = (o) => {
     out([`ringi's home is ${about().home}. A sandboxed agent must be allowed to write it.`, ...sandboxHints(about().home).map(h => `  ${h}`),
         'Otherwise agents re-run ringi commands with sandbox escalation, which you approve.'].join('\n'));
 };
-const status = () => {
-    for (const dir of [...skillTargets(false), ...skillTargets(true)]) {
-        const state = sameSkill(dir) ? 'ok      ' : fs.existsSync(dir) ? 'outdated' : 'missing ';
-        out(`${state} ${dir}`);
-    }
-};
-const uninstall = (o) => {
-    for (const dir of skillTargets(flag(o, 'project'))) {
+const uninstall = () => {
+    for (const dir of skillTargets()) {
         if (!fs.existsSync(dir))
             continue;
         fs.rmSync(dir, { recursive: true });
         out(`removed ${dir}`);
     }
 };
-const show = () => { process.stdout.write(fs.readFileSync(path.join(SKILL, 'SKILL.md'), 'utf8')); };
-const COMMANDS = new Map([['install', install], ['status', status], ['uninstall', uninstall], ['show', show]]);
+const COMMANDS = new Map([['install', install], ['uninstall', uninstall]]);
 export const skill = (o) => {
-    const run = COMMANDS.get(o._[0]) ?? fail('usage: ringi skill install [--project] | uninstall [--project] | status | show');
-    run(o);
+    const run = COMMANDS.get(o._[0]) ?? fail('usage: ringi skill install | uninstall');
+    run();
 };
 //# sourceMappingURL=index.js.map

package/target/esm/composition/index.js

@@ -9,12 +9,12 @@ import { notesTo } from '../lib/index.js';
 import { wireHub } from '../core/hub/ports/index.js';
 import { wireAgents } from '../core/agents/ports/index.js';
 import { stateFs } from '../adapters/state-fs/index.js';
-import { claude } from '../adapters/tool-claude/index.js';
-import { codex } from '../adapters/tool-codex/index.js';
-import { cursor } from '../adapters/tool-cursor/index.js';
+import { claude } from '../adapters/agent-claude/index.js';
+import { codex } from '../adapters/agent-codex/index.js';
+import { cursor } from '../adapters/agent-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 { gitTransport } from '../adapters/store-git/transport.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)));

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

@@ -24,10 +24,10 @@ const beatAll = (next) => allSessions().flatMap((s) => {
         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)
+        if (!R || R.genesis !== s.genesis || !R.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));
+        R.store.heartbeat(R.s, s.agent, R.s.tip, HB.body(b));
         return [{ session: s, beat: b }];
     }
     catch (e) {
@@ -40,7 +40,7 @@ const beatLoop = async (every, once, log) => {
         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}`);
+                log(`pulse: ${b.session.agent} in ${b.session.room}: ${b.error}`);
         idle = beats.length ? 0 : idle + 1;
         if (once || !hubPorts().state.present())
             return;
@@ -63,7 +63,7 @@ export const pulse = async ({ every = 30, once = false, log }) => {
     return 0;
 };
 // What the room's published heartbeats say, as an orchestrator would read them: whose, how old, overdue or not.
-export const published = (R) => (R.hub.store.heartbeats?.(R.s) ?? []).map(h => {
+export const published = (R) => (R.store.heartbeats?.(R.s) ?? []).map(h => {
     const next = Number(/^Next: (\d+)$/m.exec(h.text)?.[1] ?? NaN);
     const age = Math.max(0, Math.round(Date.now() / 1000 - h.time));
     return { ...h, state: /^State: (\w+)$/m.exec(h.text)?.[1] ?? '?', waits: /^Waits: (.+)$/m.exec(h.text)?.[1] ?? null, age, overdue: Number.isFinite(next) && age > next * 2 };