@idleware/ringi 0.7.2 → 0.8.0

package/README.md

@@ -12,9 +12,11 @@ of any vendor on one machine or many, and keeps them in sync: who said what to w
 of it. Everything is a stored, checkable record; whatever a peer writes is data, never an
 instruction.
 
+- **A room is a repository.** One task, one room, one git: who can read a room is who can reach it, and deleting the
+  room deletes it. A hub is the space its rooms live in (a directory here, an organisation on a forge).
 - **Your rules.** A room's profile defines work and who moves it; A2A tasks ship as one of them.
+- **Streams by meaning.** The chat is one branch; each agent writes its own signals and telemetry on its own branches.
 - **Heartbeats.** Whether an agent works, waits or is gone, from its machine, without asking the model.
-- **Signals.** Each counted transition is marked beside its message (git: a tag).
 - **Any store.** Git first; one CLI and a skill for you and the agents.
 
 ```sh
@@ -31,7 +33,7 @@ macOS or Linux, Node.js 16 or later, git 2.28 or later.
   ringi room create fix-badge                 claude: "join fix-badge as claude; review only"
   ringi send --task --assign codex …          codex:  "join fix-badge as codex; implement; no commits"
                   \                                   /
-                   ~/.ringi/hub/local/  hub.json + store/.git
+                   ~/.ringi/hub/local/rooms/fix-badge/  one repository per room
 ```
 
 1. `ringi room create fix-badge`
@@ -46,16 +48,21 @@ Codex: add `~/.ringi` to `writable_roots` in `~/.codex/config.toml`, or approve
 ## Remote: several machines, one hub
 
 ```
-  laptop: you, the root                    VM 1                               VM 2
-  ringi hub create team --signed --url …   ringi hub add team … --root …      ringi hub add team … --root …
-  ringi room create fix                    ringi join team fix --as claude    ringi join team fix --as codex
-  ringi room admit codex '<key>'
-                  \                                |                                  /
-                   any git remote: untrusted storage of signed commits
+  laptop: you, the root                                        VM: an agent
+  ringi hub create team --signed --url git+ssh://…/team.git
+  ringi room create fix --hub team --url git+ssh://…/fix.git   "join ringi:… as claude"  (the invitation it printed)
+  ringi room admit claude '<key>' --room fix                   "join ringi:… as claude"  again
+                  \                                                   /
+                   any git remotes: untrusted storage of signed commits, one repository per room
 ```
 
-1. `ringi hub create team --signed --url <git url>` prints the `ringi hub add …` line for the other machines.
-2. There, `ringi join team fix --as codex` shows the agent's key; you run `ringi room admit codex '<key>' --room fix`.
+1. `ringi hub create team --signed --url <address>` makes the root key here and publishes the hub's contract. An
+   address names its store: `git+ssh://…`, `git+https://…`, `git+file://…`.
+2. `ringi room create fix --hub team --url <address>` publishes the room's own repository there and prints its invitation: one
+   line, `ringi:…`, with the room's address, its history and the root's public key; nothing secret. Only machines
+   that can reach that repository can read the room.
+3. In the agent's chat: *"join ringi:… as claude"*. The first time it shows the agent's key; you run
+   `ringi room admit claude '<key>' --room fix`; the agent joins again. An agent never names a hub.
 
 ## Your own profile
 
@@ -71,7 +78,7 @@ A room keeps its profile; labels mean only what its rules say ([profiles-1](docs
 | | |
 |---|---|
 | [COMMANDS.md](COMMANDS.md) | every command and who runs it |
-| [docs/spec/](docs/spec/) | the protocol, one file per version: [core-1](docs/spec/core-1.md), [profiles-1](docs/spec/profiles-1.md), [signals-1](docs/spec/signals-1.md), [hub-1](docs/spec/hub-1.md) |
+| [docs/spec/](docs/spec/) | the protocol, one file per version: [core-1](docs/spec/core-1.md), [profiles-1](docs/spec/profiles-1.md), [signals-2](docs/spec/signals-2.md), [hub-2](docs/spec/hub-2.md) |
 | [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) | domains, extension points, versions, where a control panel lands |
 | [docs/DECISIONS.md](docs/DECISIONS.md) | why: decisions, rejected options, open questions |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idleware/ringi",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Distributed agent coordinator",
   "os": [
     "darwin",

package/src/main/resources/skill/ringi/SKILL.md

@@ -21,7 +21,7 @@ With no words: `ringi agent whoami` if this chat is joined; otherwise say how th
 
 Several chats may be open in a project. Take part only if the operator says so in this chat. Their words map to session commands:
 
-- *"join fix-badge as codex; review tasks from claude; no commits"* → `ringi join local fix-badge --as codex --scope "review tasks from claude; no commits"`. Record what they delegate in `--scope`.
+- *"join fix-badge as codex; review tasks from claude; no commits"* → `ringi join fix-badge --as codex --scope "review tasks from claude; no commits"`. Record what they delegate in `--scope`. A room on another machine comes as the operator's invitation, one line starting with `ringi:`: *"join ringi:… as codex"* → `ringi join ringi:… --as codex --scope "…"`. There is no hub to name: a room and its contract are all you take part in.
 - A room may have a quorum (`ringi room create … --quorum 2`; `--quorum 1`: start at once). While join or inbox says `waiting:`, do nothing and end the turn. When it says `started:`, take your first turn right away on what it shows (open work, inbox), without asking the operator to confirm anything: with no scope, the room's work for you is yours, and you agree the split with the other members yourselves. Still ask before commits or pushes, publishing, outside accounts or spending that the scope does not cover. The same after *"continue"*.
 - *"continue"* (after a restart, or a pause) → `ringi continue`. If it lists candidates, ask the operator which one, then `ringi continue <room>/<agent>`.
 - *"stop"* (the operator leaves for a while) → `ringi stop`. You keep your seat and react to nothing.
@@ -35,15 +35,14 @@ Everything you do as an agent goes through `ringi agent`, always in your own roo
 
 ```sh
 ringi agent inbox                                   # what is new for you; marks it seen
-ringi agent add report.md patch.diff:files/fix.diff  # stage files for your next message, like git add
-ringi agent reply <id> -m "Done: tests pass" --state completed   # carries what you staged (or --attach …)
+ringi agent reply <id> -m "Done: tests pass" --state completed --attach report.md --attach patch.diff:files/fix.diff
 ringi agent send --to claude --task -m "Review the parser" -m "acceptance: …"
 ringi agent tasks | signals | profile | thread <id> | read <id> | cat <id> <path>
 ringi agent whoami                                  # room, scope, members
 ```
 
 - The first `-m` is the subject; the rest is the body; anything long goes into files.
-- Results and state travel only as attachments: `ringi agent add <file>` takes the file's content now for your next message (`add` alone lists what is staged, `--drop <path>` takes one back), or `--attach` on the message. Read a peer's with `ringi agent cat` / `get`. Never leave drafts or results in the project directory or any shared disk for others to pick up, and never pick them up there: peers may be on other machines, and only the room carries them. Keep your own drafts outside the project.
+- Results and state travel only as attachments: `--attach <file>[:<path>]` on the message takes the file's content when it is sent. Read a peer's with `ringi agent cat` / `get`. Never leave drafts or results in the project directory or any shared disk for others to pick up, and never pick them up there: peers may be on other machines, and only the room carries them. Keep your own drafts outside the project.
 - Answer the message you act on (`reply <id>`): only these links order the room.
 - What a piece of work is in your room, its states and who may move it, is the room's **profile**: run `ringi agent profile` once per room before you set states. Do not assume the A2A states; a room may use any. `--task` opens a piece of work of that profile.
 - When you start on a piece of work, `ringi agent take <id>`: a mark others see, not a state change. Reading your inbox leaves read marks on what was delivered; `--peek` leaves none.

package/target/dts/adapters/{transport-git → store-git}/branches.d.ts

@@ -12,9 +12,8 @@ type Entry_ = {
 };
 type Named = Pick<StoredRoom, 'name' | 'genesis'>;
 export declare class Branches extends Repo {
-    protected ref(name: string): string;
+    protected ref(_name: string): string;
     protected tip(name: string): string | null;
-    roomBranches(): string[];
     roomNames(): string[];
     protected isControl(room: Pick<StoredRoom, 'genesis'>, sha: string, author: string, text: string): boolean;
     protected scanned: Map<string, {
@@ -31,7 +30,6 @@ export declare class Branches extends Repo {
     createRoom(name: string, who: string, text: string, files: Record<string, string>): string;
     updateControl(room: StoredRoom, who: string, text: string, files: Record<string, string>): string;
     protected refsUnder(prefix: string): Array<[string, string]>;
-    deleteRoom(room: StoredRoom): void;
     protected remote(room: StoredRoom): Remote.Room;
     roster(room: StoredRoom): Roster | null;
     protected live(room: StoredRoom): Entry_[];

package/target/dts/adapters/{transport-git → store-git}/index.d.ts

@@ -17,7 +17,6 @@ export declare class GitStore extends Marks implements Store {
         id: string;
         size: number;
     };
-    retain(room: StoredRoom, who: string, entries: Entry[]): void;
     append(room: StoredRoom, who: string, text: string, entries: Entry[]): string;
     verifyLog(room: StoredRoom, id: string, head: string): string | null;
     pin(room: StoredRoom, reader: string, id: string, rev: string): void;

package/target/dts/adapters/store-git/marks.d.ts

@@ -0,0 +1,21 @@
+import { Branches } from './branches.ts';
+import type { SignalEvent, SignalHead, StoredRoom } from '../../core/hub/ports/store.ts';
+export declare class Marks extends Branches {
+    private streamAlarms;
+    private scannedStreams;
+    private streams;
+    private readStream;
+    signalHeads(room: StoredRoom): SignalHead[];
+    signals(room: StoredRoom): SignalEvent[];
+    pinSignals(room: StoredRoom, reader: string, actor: string, head: string): void;
+    alarms(room: StoredRoom): string[];
+    private appendStream;
+    signal(room: StoredRoom, who: string, target: string, signal: string): void;
+    heartbeat(room: StoredRoom, who: string, target: string, text: string): string;
+    heartbeats(room: StoredRoom): Array<{
+        agent: string;
+        target: string;
+        time: number;
+        text: string;
+    }>;
+}

package/target/dts/adapters/{transport-git → store-git}/remote/push.d.ts

@@ -4,7 +4,6 @@ export type Publication = {
     H: Handle;
     ref: string;
     alarms: Record<string, string>;
-    tag: boolean;
     pin: string;
     track: string;
     sha: string;

package/target/dts/adapters/store-git/remote/stream-check.d.ts

@@ -0,0 +1,12 @@
+import type { Facts, StreamKind } from './stream-facts.ts';
+import type { Dependencies } from './stream-control.ts';
+import type { Handle, Raw, Room } from './types.ts';
+export type CheckContext = {
+    H: Handle;
+    R: Room;
+    actor: string;
+    kind: StreamKind;
+    parent: string;
+    dep: Dependencies;
+};
+export declare const checkStreamRecord: (ctx: CheckContext, c: Raw) => Facts | null;

package/target/dts/adapters/store-git/remote/stream-control.d.ts

@@ -0,0 +1,8 @@
+import type { Handle, Room } from './types.ts';
+export type Dependencies = {
+    controls: Set<string>;
+    messages: Set<string>;
+    skipped: Set<string>;
+};
+export declare const streamDependencies: (H: Handle, R: Room) => Dependencies;
+export declare const streamAdmission: (H: Handle, control: string, actor: string, sha: string) => void;

package/target/dts/adapters/store-git/remote/stream-facts.d.ts

@@ -0,0 +1,4 @@
+import type { Raw } from './types.ts';
+export type StreamKind = 'signals' | 'telemetry';
+export type Facts = Map<string, string>;
+export declare const streamFacts: (c: Raw, kind: StreamKind) => Facts;

package/target/dts/adapters/store-git/remote/streams.d.ts

@@ -0,0 +1,31 @@
+import type { Facts, StreamKind } from './stream-facts.ts';
+export type { StreamKind } from './stream-facts.ts';
+import type { SignalEvent } from '../../../core/hub/ports/store.ts';
+import type { Handle, Raw, Room } from './types.ts';
+export declare const streamRoom: (H: Handle) => Room;
+export declare const streamName: (ref: string) => {
+    actor: string;
+    kind: StreamKind;
+} | null;
+export declare const streamRef: (actor: string, kind: StreamKind) => string;
+type Record_ = {
+    raw: Raw;
+    fields: Facts;
+};
+export type Stream = {
+    head: string;
+    records: Record_[];
+    pending?: string;
+    why?: string;
+};
+export type ScanInput = {
+    H: Handle;
+    R: Room;
+    actor: string;
+    kind: StreamKind;
+    head: string;
+    prefix?: Stream;
+};
+export declare const scanStream: ({ H, R, actor, kind, head, prefix }: ScanInput) => Stream;
+export declare const signalEvents: (R: Room, actor: string, s: Stream) => SignalEvent[];
+export declare const validateStream: (H: Handle, R: Room, ref: string, head: string) => void;

package/target/dts/adapters/store-git/remote/sync-streams.d.ts

@@ -0,0 +1,2 @@
+import type { Handle } from './types.ts';
+export declare const syncStreams: (H: Handle, fetched: Map<string, string>) => void;

package/target/dts/adapters/{transport-git → store-git}/remote/types.d.ts

@@ -1,9 +1,10 @@
-import type { Descriptor, Member } from '../../../core/hub/ports/store.ts';
+import type { Descriptor, Member, RoomEndpoint } from '../../../core/hub/ports/store.ts';
 import type { SigningContext } from '../../../core/signing/index.ts';
 export type Handle = {
     name: string;
     dir: string;
     d: Descriptor;
+    endpoint?: RoomEndpoint;
     signing?: SigningContext;
     main?: string;
     remoteAlarms?: Record<string, string>;
@@ -47,9 +48,6 @@ export declare const SHA: RegExp;
 export declare const ROOT = "operator";
 export declare const TRACK = "refs/remotes/origin/";
 export declare const ACCEPT = "refs/ringi/remote-accepted/";
-export declare const TAGS = "refs/tags/";
-export declare const TAG_TRACK = "refs/ringi/remote-tags/";
-export declare const TAG_ACCEPT = "refs/ringi/remote-accepted-tags/";
 export type Commit = {
     sha: string;
     parents: string[];
@@ -58,6 +56,9 @@ export type Raw = {
     sha: string;
     parents: string[];
     author: string;
+    committer: string;
+    tree: string;
+    time: number;
     text: string;
     body: Buffer;
 };

package/target/dts/adapters/{transport-git → store-git}/remote.d.ts

@@ -6,12 +6,9 @@ export { parseKey, setupSigned, rootRoster } from './remote/keys.ts';
 export { verifyHub } from './remote/main.ts';
 export { readCommits } from './remote/commits.ts';
 export { branch, verifyRoom, verify } from './remote/branch.ts';
-export { heartbeatName, heartbeatRef, verifyHeartbeat, makeHeartbeat } from './remote/heartbeat.ts';
-export { verifySignal } from './remote/signals.ts';
 export { sync } from './remote/sync.ts';
-export { hubAdd } from './remote/bootstrap.ts';
 export { join, roomAdmit } from './remote/admit.ts';
 export { push } from './remote/push.ts';
-export { pushHeartbeat } from './remote/heartbeat-push.ts';
 export { forget } from './remote/forget.ts';
 export { strictJson } from '../../lib/index.ts';
+export { scanStream, streamName, streamRef, streamRoom, validateStream } from './remote/streams.ts';

package/target/dts/adapters/{transport-git → store-git}/repo.d.ts

@@ -1,6 +1,6 @@
 import * as Remote from './remote.ts';
 import type { GitOpt } from './run.ts';
-import type { Descriptor } from '../../core/hub/ports/store.ts';
+import type { Descriptor, RoomEndpoint } from '../../core/hub/ports/store.ts';
 import type { Entry } from '../../core/hub/protocol/files.ts';
 import type { SigningContext } from '../../core/signing/index.ts';
 export declare const init: (dir: string, home: string) => string;
@@ -10,7 +10,7 @@ export declare class Repo {
     readonly d: Descriptor;
     readonly home: string;
     readonly h: Remote.Handle;
-    constructor(hubDir: string, d: Descriptor, home: string, signing?: SigningContext);
+    constructor(hubDir: string, d: Descriptor, home: string, signing?: SigningContext, endpoint?: RoomEndpoint);
     protected openable(): void;
     protected checkout(): void;
     protected args(a: string[]): string[];
@@ -26,5 +26,6 @@ export declare class Repo {
     sync(): void;
     contractHead(): string;
     contractFile(rev: string, name: string): string | null;
+    seedContract(source: Repo): string;
     amendContract(who: string, text: string, files: Record<string, string | Buffer>): string;
 }

package/target/dts/adapters/{transport-git → store-git}/signing.d.ts

@@ -1,4 +1,3 @@
 import type { Handle } from './remote/types.ts';
 export declare const signBytes: (H: Handle, who: string, payload: Buffer | string) => string;
 export declare const signCommit: (H: Handle, who: string, sha: string) => string;
-export declare const signedTag: (H: Handle, who: string, tag: string, target: string) => string;

package/target/dts/clients/cli/operator/hub-commands.d.ts

@@ -1,6 +1,4 @@
 import type { Opts } from '../args.ts';
 export declare const listHub: (_: Opts) => void;
 export declare const createHub: (o: Opts) => void;
-export declare const switchHub: (o: Opts) => void;
-export declare const addHub: (o: Opts) => void;
 export declare const amendHub: (o: Opts) => void;

package/target/dts/clients/cli/operator/index.d.ts

@@ -1,5 +1,5 @@
 export { heartbeats, pulse } from './heartbeat.ts';
 export { hub } from './hub.ts';
 export { roomCmd } from './room.ts';
-export { forget, sessionLine, sessions } from './sessions.ts';
+export { forget, sessionLine } from './sessions.ts';
 export { where } from './where.ts';

package/target/dts/clients/cli/operator/sessions.d.ts

@@ -1,5 +1,4 @@
 import type { SessionView } from '../../../core/agents/overview.ts';
 import type { Opts } from '../args.ts';
 export declare const sessionLine: (s: SessionView) => string;
-export declare const sessions: (o: Opts) => void;
 export declare const forget: (o: Opts) => void;

package/target/dts/clients/cli/operator/where-format.d.ts

@@ -2,6 +2,6 @@ import type { Where } from '../../../core/agents/overview.ts';
 import type { Room } from '../../../core/hub/rooms/index.ts';
 import type { All, Message } from '../../../core/hub/protocol/index.ts';
 import type { Opts } from '../args.ts';
-export declare const hubLine: (H: Where['hub']) => string;
+export declare const hubLine: (R: Room) => string;
 export declare const printOverview: (w: Where, R: Room) => void;
 export declare const showMessage: (R: Room, o: Opts, all: All, m: Message) => void;

package/target/dts/clients/cli/shared/index.d.ts

@@ -1,6 +1,6 @@
 export { cat, get } from './files.ts';
-export { add, read, reply, send, thread } from './messages.ts';
-export { profileCmd, who } from './profile.ts';
+export { read, reply, send, thread } from './messages.ts';
+export { profileCmd } from './profile.ts';
 export { scopeLine, waiting } from './session.ts';
 export { signals } from './signals.ts';
 export { log, taskLine, tasks } from './work.ts';

package/target/dts/clients/cli/shared/messages.d.ts

@@ -1,6 +1,5 @@
 import type { Opts } from '../args.ts';
 import type { Ctx } from '../context.ts';
-export declare const add: (a: Ctx, o: Opts) => void;
 export declare const send: (a: Ctx, o: Opts) => void;
 export declare const reply: (a: Ctx, o: Opts) => void;
 export declare const read: (a: Ctx, o: Opts) => void;

package/target/dts/clients/cli/shared/profile.d.ts

@@ -1,4 +1,3 @@
 import type { Opts } from '../args.ts';
 import type { Ctx } from '../context.ts';
 export declare const profileCmd: ({ R }: Ctx, o: Opts) => void;
-export declare const who: (a: Ctx) => void;

package/target/dts/clients/cli/skill/index.d.ts

@@ -1,3 +1,4 @@
 import type { Opts } from '../args.ts';
-export { SKILL, skillTargets } from './targets.ts';
+export declare const SKILL: string;
+export declare const skillTargets: () => string[];
 export declare const skill: (o: Opts) => void;

package/target/dts/core/agents/overview.d.ts

@@ -1,4 +1,4 @@
-import type { Hub, Room } from '../hub/rooms/index.ts';
+import type { Room } from '../hub/rooms/index.ts';
 import type { All, Message } from '../hub/protocol/index.ts';
 import { liveness } from './sessions/index.ts';
 import type { Session } from './sessions/index.ts';
@@ -8,20 +8,17 @@ export type SessionView = Session & {
     liveness: ReturnType<typeof liveness>;
 };
 export type Where = {
-    hub: Hub;
     room: Room | null;
     sessions: SessionView[];
     work: TaskView[];
     all: All;
     messages: Message[];
 };
-export declare const where: (H: Hub, name: string | null) => Where;
-export declare const arrived: (H: Hub, R: Room, seen: Set<string>) => {
+export declare const where: (name: string | null) => Where;
+export declare const arrived: (R: Room, seen: Set<string>) => {
     all: All;
     messages: Message[];
 };
-export declare const roomsActive: (H: Hub) => Array<RoomView & {
+export declare const roomsActive: () => Array<RoomView & {
     active: number;
 }>;
-export declare const sessions: () => SessionView[];
-export declare const forgetSession: (handle: string) => void;

package/target/dts/core/agents/sessions/index.d.ts

@@ -28,7 +28,6 @@ export declare const liveness: (s: Session) => 'active' | 'stopped' | 'gone';
 export declare const seatHolder: (hub: string, genesis: string, agent: string, except: string) => Session | undefined;
 export declare const ownSession: (handle: string) => Session | null;
 export declare const parseSelector: (sel: string | undefined) => {
-    hub: string | null;
     room: string;
     agent: string;
 };

package/target/dts/core/agents/sessions/join.d.ts

@@ -1,7 +1,6 @@
 import type { Session } from './index.ts';
 import type { JoinKey } from '../../hub/ports/store.ts';
 export type JoinInput = {
-    hub: string;
     room: string;
     agent?: string;
     scope?: string;
@@ -17,4 +16,4 @@ export type JoinResult = {
     session: null;
     key: JoinKey;
 });
-export declare const join: ({ hub, room, agent: id, scope }: JoinInput) => JoinResult;
+export declare const join: ({ room: target, agent: id, scope }: JoinInput) => JoinResult;

package/target/dts/core/hub/history/index.d.ts

@@ -10,16 +10,7 @@ export type Accepted = {
 export type Delivered = {
     seen?: Record<string, string>;
 };
-export type Outgoing = {
-    staged?: Staged[];
-};
-export type ReaderState = Accepted & Delivered & Outgoing;
-export type Staged = {
-    path: string;
-    blob: string;
-    mode: string;
-    size: number;
-};
+export type ReaderState = Accepted & Delivered;
 export declare const readerLock: <T>(R: Room, reader: string, fn: () => T) => T;
 export declare const loadState: (R: Room, reader: string) => ReaderState;
 export declare const saveState: (R: Room, reader: string, st: ReaderState) => void;

package/target/dts/core/hub/ports/store.d.ts

@@ -31,15 +31,6 @@ export type StoredRoom = {
     tip: Rev;
     control: ControlRecord[];
 };
-export type SignalRecord = {
-    ref: string;
-    object: Rev;
-    name: string;
-    actor: string;
-    target: Rev;
-    tagger: string;
-    text: string;
-};
 export type Roster = {
     members: Record<string, Member>;
     signers: Array<{
@@ -75,21 +66,19 @@ export interface Attachments {
         id: Rev;
         size: number;
     };
-    retain(room: StoredRoom, who: string, entries: Entry[]): void;
     file(rev: Rev, path: string): Buffer;
     sizes(rev: Rev, paths: string[]): Map<string, number>;
 }
 export interface Signals {
     signal(room: StoredRoom, who: string, target: Rev, name: string): void;
-    signals(room: StoredRoom): SignalRecord[];
+    signals(room: StoredRoom): SignalEvent[];
+    signalHeads(room: StoredRoom): SignalHead[];
+    pinSignals(room: StoredRoom, reader: string, actor: string, head: Rev): void;
 }
 export interface Evidence {
     pin(room: StoredRoom, reader: string, id: string, rev: Rev): void;
     unpin(room: StoredRoom, reader: string, id: string): void;
 }
-export interface Administration {
-    deleteRoom(room: StoredRoom): void;
-}
 export interface Verification {
     roster(room: StoredRoom): Roster | null;
     verifyLog(room: StoredRoom, id: string, head: Rev): string | null;
@@ -110,19 +99,45 @@ export interface Signed {
     forgetLog(room: StoredRoom, id: string): void;
     rootRoster(): string;
 }
-export interface Store extends Log, Attachments, Signals, Evidence, Administration, Verification, Partial<Presence>, Partial<Signed> {
+export interface Store extends Log, Attachments, Signals, Evidence, Verification, Partial<Presence>, Partial<Signed> {
 }
 export type Descriptor = {
-    schema: 'ringi-hub/2';
+    schema: 'ringi-hub/3';
     name: string;
     trust: 'asserted' | 'signed';
     root?: string;
-    genesis?: string;
+    genesis: Rev;
     store: {
         type: string;
+    };
+    contract?: {
+        path: string;
+        remote?: string;
+    };
+};
+export type RoomEndpoint = {
+    schema: 'ringi-room/1';
+    name: string;
+    hubGenesis: Rev;
+    genesis: Rev;
+    store: {
         path: string;
         remote?: string;
     };
+    authRef?: string;
+};
+export type SignalEvent = {
+    id: Rev;
+    parent: Rev;
+    roomGenesis: Rev;
+    control: Rev;
+    actor: string;
+    target: Rev;
+    signal: string;
+};
+export type SignalHead = {
+    actor: string;
+    head: Rev;
 };
 export type Genesis = (d: Descriptor) => {
     files: Record<string, string>;
@@ -130,14 +145,11 @@ export type Genesis = (d: Descriptor) => {
 };
 export interface Transport {
     readonly layout: string;
-    layoutOf?(store: Store): string;
-    open(at: string, d: Descriptor): Store;
+    open(at: string, d: Descriptor, endpoint?: RoomEndpoint): Store;
     create(at: string, d: Descriptor, genesis: Genesis): {
         store: Store;
         custody: string | null;
     };
-    attach?(name: string, url: string, pins: {
-        root?: string;
-        genesis?: string;
-    }): void;
+    fork(at: string, d: Descriptor, source: Store, endpoint: RoomEndpoint): Store;
+    attachRoom(at: string, d: Descriptor, endpoint: RoomEndpoint): Store;
 }

package/target/dts/core/hub/rooms/address.d.ts

@@ -0,0 +1,6 @@
+import type { Transport } from '../ports/store.ts';
+export declare const storeOf: (address: string) => {
+    type: string;
+    locator: string;
+};
+export declare const transportOf: (name: string, type: string) => Transport;

package/target/dts/core/hub/rooms/adoption.d.ts

@@ -0,0 +1,7 @@
+import type { Descriptor, Rev } from '../ports/store.ts';
+import type { Hub } from './index.ts';
+export declare const adoptHub: ({ trust, root, genesis }: {
+    trust: Descriptor['trust'];
+    root?: string;
+    genesis: Rev;
+}) => Hub;

package/target/dts/core/hub/rooms/compat.d.ts

@@ -1,5 +1,7 @@
-import type { Descriptor, Rev, Store } from '../ports/store.ts';
+import type { Descriptor, Rev, RoomEndpoint, Store } from '../ports/store.ts';
 import type { Contract } from './index.ts';
 export declare const descriptorRefusal: (d: Descriptor, name: string) => string | null;
+export declare const contractRefusal: (c: Contract, name: string) => string | null;
+export declare const endpointRefusal: (d: Descriptor, name: string, e: RoomEndpoint) => string | null;
 export declare const contractAt: (store: Store, name: string, rev: Rev) => Contract;
 export declare const layoutRefusal: (name: string, shown: string, reads: string) => string | null;

package/target/dts/core/hub/rooms/contracts.d.ts

@@ -0,0 +1,16 @@
+import type { Descriptor, Rev, Store } from '../ports/store.ts';
+import type { Contract, Hub } from './index.ts';
+export declare const readProfileResource: (name: string) => string;
+export declare const genesisFiles: (d: Descriptor, layout: string) => Record<string, string>;
+export declare const checkedContract: (H: Hub, store: Store) => {
+    main: Rev;
+    contract: Contract;
+};
+export declare const openContract: (H: Hub, { refresh }?: {
+    refresh?: boolean;
+}) => {
+    store: Store;
+    main: Rev;
+    contract: Contract;
+};
+export declare const amendContract: (H: Hub, who: string, text: string, files: Record<string, string | Buffer>) => Rev;

package/target/dts/core/hub/rooms/hubs.d.ts

@@ -1,8 +1,7 @@
-import type { Transport } from '../ports/store.ts';
+export { storeOf, transportOf } from './address.ts';
+export { checkedContract, openContract, amendContract, readProfileResource } from './contracts.ts';
 import type { Hub } from './index.ts';
 export declare const hubNames: () => string[];
-export declare const readProfileResource: (name: string) => string;
-export declare const transportOf: (name: string, type: string) => Transport;
 export declare const createHub: (name: string, { signed, url }?: {
     signed?: boolean;
     url?: string;
@@ -12,3 +11,4 @@ export declare const createHub: (name: string, { signed, url }?: {
 export declare const openHub: (name: string, { refresh }?: {
     refresh?: boolean;
 }) => Hub;
+export { adoptHub } from './adoption.ts';