@idleware/ringi 0.6.1 → 0.7.1

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() });

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;
 };