@idleware/ringi 0.7.1 → 0.8.0

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

@@ -1,7 +1,7 @@
 import type { Profile } from '../work/index.ts';
-import type { Descriptor, Member, Rev, Store, StoredRoom } from '../ports/store.ts';
+import type { Descriptor, Member, Rev, RoomEndpoint, Store, StoredRoom } from '../ports/store.ts';
 export declare const OPERATOR = "operator";
-export declare const HUB_MAJOR = 1;
+export declare const HUB_MAJOR = 2;
 export declare const PROTOCOL_MAJOR = 1;
 export declare const CAPS: Set<string>;
 export declare const RESERVED_ROOMS: Set<string>;
@@ -11,7 +11,7 @@ export type Contract = {
     protocol: number;
     trust: 'asserted' | 'signed';
     capabilities?: string[];
-    store?: string;
+    store: string;
     profile?: string;
     root?: string;
 };
@@ -19,13 +19,12 @@ export type Hub = {
     name: string;
     dir: string;
     d: Descriptor;
-    store: Store;
-    main: Rev;
-    contract: Contract;
     signed: boolean;
 };
 export type Room = {
     hub: Hub;
+    endpoint: RoomEndpoint;
+    store: Store;
     s: StoredRoom;
     name: string;
     head: Rev;

package/target/dts/core/hub/rooms/room-catalogue.d.ts

@@ -0,0 +1,9 @@
+import type { RoomEndpoint, Store } from '../ports/store.ts';
+import type { Hub } from './index.ts';
+export declare const endpointKey: (H: Hub, name: string) => string[];
+export declare const roomDir: (H: Hub, name: string) => string;
+export declare const transportFor: (H: Hub, e: RoomEndpoint) => import("../ports/store.ts").Transport;
+export declare const roomLock: (H: Hub, name: string) => string;
+export declare const uniqueName: (H: Hub, name: string) => void;
+export declare const roomNames: (H: Hub) => string[];
+export declare const selectedStore: (H: Hub, endpoint: RoomEndpoint) => Store;

package/target/dts/core/hub/rooms/room-life.d.ts

@@ -0,0 +1,10 @@
+import type { RoomEndpoint } from '../ports/store.ts';
+import type { Hub, Room } from './index.ts';
+export declare const createRoom: (H: Hub, name: string, { who, text, files, remote }: {
+    who: string;
+    text: string;
+    files: Record<string, string>;
+    remote?: string;
+}) => Room;
+export declare const attachRoom: (H: Hub, name: string, endpoint: RoomEndpoint) => Room;
+export declare const deleteRoom: (R: Room) => void;

package/target/dts/core/hub/rooms/room-view.d.ts

@@ -0,0 +1,3 @@
+import type { RoomEndpoint, Store } from '../ports/store.ts';
+import type { Hub, Room } from './index.ts';
+export declare const openedRoom: (H: Hub, endpoint: RoomEndpoint, store: Store) => Room;

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

@@ -1,8 +1,10 @@
 import type { Member } from '../ports/store.ts';
 import type { Hub, Room } from './index.ts';
-export declare const roomNames: (H: Hub) => string[];
-export declare const openRoom: (H: Hub, name: string | null | undefined, { quiet }?: {
+export { roomNames } from './room-catalogue.ts';
+export { createRoom, attachRoom, deleteRoom } from './room-life.ts';
+export declare const openRoom: (H: Hub, name: string | null | undefined, { quiet, refresh }?: {
     quiet?: boolean;
+    refresh?: boolean;
 }) => Room | null;
 export declare const room: (H: Hub, name: string | null | undefined) => Room;
 export declare const ROOM_MD: (name: string) => string;

package/target/dts/core/hub/signals/check.d.ts

@@ -1,3 +1,3 @@
 import type { All } from '../protocol/index.ts';
-import type { Checked, RoomModel, SignalRecord } from './model.ts';
-export declare const check: (R: RoomModel, all: All, records: SignalRecord[]) => Checked[];
+import type { Checked, RoomModel, SignalEvent } from './model.ts';
+export declare const check: (R: RoomModel, all: All, records: SignalEvent[]) => Checked[];

package/target/dts/core/hub/signals/model.d.ts

@@ -5,15 +5,7 @@ export type RoomModel = {
     profile: Profile;
     members: Record<string, unknown>;
 };
-export type SignalRecord = {
-    ref: string;
-    object: string;
-    name: string;
-    actor: string;
-    target: string;
-    tagger: string;
-    text: string;
-};
+export type { SignalEvent } from '../ports/store.ts';
 export type Checked = {
     ref: string;
     actor: string;
@@ -21,6 +13,6 @@ export type Checked = {
     target: string;
     ok: boolean;
     why?: string;
+    pending?: boolean;
 };
 export declare const MARKS: string[];
-export declare const signalName: (id: string, signal: string) => string;

package/target/dts/core/hub/signals/pins.d.ts

@@ -1,5 +1,5 @@
-import type { Checked, SignalRecord } from './model.ts';
-export declare const pins: (records: SignalRecord[], checked: Checked[], accepted?: Record<string, string>) => {
+import type { Checked, SignalEvent } from './model.ts';
+export declare const pins: (records: SignalEvent[], checked: Checked[], accepted?: Record<string, string>) => {
     accepted: Record<string, string>;
     alarms: string[];
 };

package/target/dts/core/hub/usecases/config.d.ts

@@ -1,5 +1,4 @@
 export type Config = {
-    hub: string;
     room: string | null;
 };
 export declare const config: () => Config;

package/target/dts/core/hub/usecases/context.d.ts

@@ -1,7 +1,6 @@
 import { config } from '../rooms/index.ts';
 import type { Actor } from './actor.ts';
-export declare const operator: ({ hub, room }?: {
-    hub?: string;
+export declare const operator: ({ room }?: {
     room?: string;
 }) => Actor;
 export declare const about: () => {

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

@@ -2,10 +2,9 @@ import type { Hub } from '../rooms/index.ts';
 export declare const hubOf: (name?: string) => Hub;
 export type HubView = {
     name: string;
-    current: boolean;
     store: string;
     trust: string;
-    contract: string;
+    contract: string | null;
     rooms: number;
     remote: string | null;
     dir: string;
@@ -17,13 +16,8 @@ export declare const create: (name: string, { signed, url }?: {
 }) => {
     H: Hub;
     rootKey: string | null;
-    add: string | null;
+    remote: string | null;
 };
-export declare const use: (name: string) => void;
-export declare const add: (name: string, url: string, { root, genesis }: {
-    root?: string;
-    genesis?: string;
-}) => Hub;
 export type AmendInput = {
     text: string;
     set?: string[];

package/target/dts/core/hub/usecases/invite.d.ts

@@ -0,0 +1,12 @@
+import type { Room } from '../rooms/index.ts';
+export type Invite = {
+    schema: 'ringi-invite/1';
+    room: string;
+    address: string;
+    genesis: string;
+    hubGenesis: string;
+    trust: 'signed';
+    root: string;
+};
+export declare const invite: (R: Room) => string | null;
+export declare const readInvite: (s: string) => Invite | null;

package/target/dts/core/hub/usecases/room.d.ts

@@ -5,7 +5,6 @@ import type { All, Message } from '../protocol/index.ts';
 import type { Actor } from './actor.ts';
 import type { TaskView } from './view.ts';
 export * from './actor.ts';
-export * from './staging.ts';
 export * from './send.ts';
 export declare const marks: (R: Room, all: All) => Map<string, Record<string, string[]>>;
 export declare const message: ({ R, me }: Actor, ref: string) => {

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

@@ -1,20 +1,22 @@
 import type { Hub, Room } from '../rooms/index.ts';
-export { admit, forgetLog, remove } from './roster.ts';
-export declare const roomIn: (H: Hub, name?: string | null) => Room;
+export { admit, forgetLog } from './roster.ts';
+export declare const roomNamed: (name?: string | null) => Room;
 export type RoomView = {
     name: string;
+    hub: string;
     current: boolean;
     members: number;
     profile: string;
     genesis: string;
 };
-export declare const rooms: (H: Hub) => RoomView[];
-export declare const create: (H: Hub, name: string, { profile, quorum }?: {
+export declare const rooms: () => RoomView[];
+export declare const create: (H: Hub, name: string, { profile, quorum, url }?: {
     profile?: string;
     quorum?: number;
+    url?: string;
 }) => {
     profile: string;
+    join: string | null;
 };
-export declare const use: (H: Hub, name: string) => Room;
-export declare const erase: (H: Hub, R: Room) => void;
-export declare const rebase: (H: Hub, R: Room) => void;
+export declare const use: (name: string) => Room;
+export declare const erase: (R: Room) => void;

package/target/dts/core/hub/usecases/roster.d.ts

@@ -1,5 +1,4 @@
 import type { Hub, Room } from '../rooms/index.ts';
-export declare const notSigned: (H: Hub, what: string) => void;
+export declare const agentId: (who: string) => string;
 export declare const admit: (H: Hub, R: Room, who: string, key: string) => void;
-export declare const remove: (H: Hub, R: Room, who: string) => void;
 export declare const forgetLog: (H: Hub, R: Room, id: string) => number;

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

@@ -5,7 +5,6 @@ export declare const PROFILES_CAPABILITY = "profiles/1";
 export type Rules = {
     assign?: string[];
     roles?: string[];
-    grant?: string[];
     [state: `state:${string}`]: string[] | undefined;
 };
 export type Profile = {

package/target/dts/index.d.ts

@@ -2,6 +2,6 @@ import './composition/index.ts';
 export * from './core/hub/protocol/index.ts';
 export * from './core/hub/work/index.ts';
 export * as signals from './core/hub/signals/index.ts';
-export type { Store, Transport, Descriptor, StoredRoom, StoredMessage, SignalRecord, Rev } from './core/hub/ports/store.ts';
+export type { Store, Transport, Descriptor, RoomEndpoint, StoredRoom, StoredMessage, SignalEvent, SignalHead, Rev } from './core/hub/ports/store.ts';
 export { openHub, openRoom, createHub, contractAt } from './core/hub/rooms/index.ts';
 export type { Hub, Room, Contract } from './core/hub/rooms/index.ts';

package/target/dts/lib/fail.d.ts

@@ -1,3 +1,4 @@
+export declare const withoutCredentials: (text: string) => string;
 export declare class Fail extends Error {
 }
 export declare const fail: (msg: string) => never;

package/target/esm/adapters/{tool-claude → agent-claude}/index.js

@@ -1,10 +1,10 @@
-// tool-claude: Claude Code. A session says so in its environment (CLAUDECODE, CLAUDE_CODE_SESSION_ID) and is known by
+// agent-claude: Claude Code. A session says so in its environment (CLAUDECODE, CLAUDE_CODE_SESSION_ID) and is known by
 // its session id, `claude:<id>`. While it works it writes its transcript
 // $CLAUDE_CONFIG_DIR (or ~/.claude)/projects/<dir>/<session id>.jsonl; it reads skills from .claude/skills.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { UUID, mtime, newestFirst } from '../tool-traces/index.js';
+import { UUID, mtime, newestFirst } from '../agent-traces/index.js';
 const transcript = (id) => {
     const root = path.join(process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), '.claude'), 'projects');
     const dir = newestFirst(root).find(d => fs.existsSync(path.join(root, d, `${id}.jsonl`)));

package/target/esm/adapters/{tool-codex → agent-codex}/index.js

@@ -1,10 +1,10 @@
-// tool-codex: Codex. A session says so in its environment (CODEX_*); a chat names itself on every ringi command with
+// agent-codex: Codex. A session says so in its environment (CODEX_*); a chat names itself on every ringi command with
 // RINGI_SESSION=codex-<thread id>. While it works it writes its rollout
 // $CODEX_HOME (or ~/.codex)/sessions/<yyyy>/<mm>/<dd>/rollout-<time>-<thread id>.jsonl; it reads skills from
 // .agents/skills, and its sandbox writes where its writable roots allow.
 import os from 'node:os';
 import path from 'node:path';
-import { UUID, mtime, newestFirst } from '../tool-traces/index.js';
+import { UUID, mtime, newestFirst } from '../agent-traces/index.js';
 const rollout = (id) => {
     const root = path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'), 'sessions');
     for (const y of newestFirst(root))

package/target/esm/adapters/{tool-cursor → agent-cursor}/index.js

@@ -1,4 +1,4 @@
-// tool-cursor: Cursor, recognised only: a session says so in its environment (CURSOR_*) or by its process. It names no
+// agent-cursor: Cursor, recognised only: a session says so in its environment (CURSOR_*) or by its process. It names no
 // session, writes no trace ringi reads, and gets no skill.
 export const cursor = {
     id: 'cursor',

package/target/esm/adapters/{tool-traces → agent-traces}/index.js

@@ -1,4 +1,4 @@
-// tool-traces: what the tool adapters share to find a session's trace: a session id at the end of a name, directories
+// agent-traces: what the agent adapters share to find a session's trace: a session id at the end of a name, directories
 // newest first, and when a file was last written.
 import fs from 'node:fs';
 export const UUID = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/;

package/target/esm/adapters/state-fs/index.js

@@ -5,7 +5,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { errno, fail, strictJson } from '../../lib/index.js';
 import { guardWrite, locked as lockFile, mkdirIn, writeJsonAtomic } from '../fs/index.js';
-const HOME_VERSION = 3;
+const HOME_VERSION = 4;
 // State fails closed: unreadable JSON is an error, never a silent fresh start.
 const readJson = (f, dflt) => {
     let raw;
@@ -40,7 +40,7 @@ export const stateFs = ({ root, build }) => {
             if (fs.existsSync(marker)) {
                 const v = readJson(marker, {}).version;
                 if (v !== HOME_VERSION)
-                    fail(`${root} is a ringi home of version ${v}; this ringi ${build.version} needs version ${HOME_VERSION}: set RINGI_HOME to a new directory for a fresh home; ringi does not migrate`);
+                    fail(`${root} is a ringi home of version ${v}; this ringi ${build.version} needs version ${HOME_VERSION}. Move it away (the ringi that made it still reads it with RINGI_HOME pointing there) or set RINGI_HOME to a new directory; ringi does not migrate`);
                 return;
             }
             if (fs.existsSync(root) && fs.readdirSync(root).length)

package/target/esm/adapters/{transport-git → store-git}/branches.js

@@ -4,23 +4,17 @@ import { fail } from '../../lib/index.js';
 import * as Remote from './remote.js';
 import { ZERO } from './run.js';
 import { Repo } from './repo.js';
-import { ID_RE, parse } from '../../core/hub/protocol/index.js';
+import { parse } from '../../core/hub/protocol/index.js';
 // The root's principal, and the files only its control records may change.
 const ROOT = 'operator';
 export const CONTROL_FILES = new Set(['ROOM.md', 'members.json', 'profile.json', 'allowed_signers']);
 export class Branches extends Repo {
-    ref(name) { return `refs/heads/${name}`; }
+    ref(_name) { return 'refs/heads/chat'; }
     tip(name) { return this.rev(this.ref(name)); }
-    // Every branch but the contract's, by name.
-    roomBranches() {
-        return this.git(['for-each-ref', '--format=%(refname:lstrip=2)', 'refs/heads/']).split('\n').filter(b => b && b !== 'main');
-    }
-    // Every branch but the contract's is a room.
+    // One repository holds one chat. Its logical name is pinned by the local endpoint.
     roomNames() {
-        const prefix = 'refs/heads/';
-        const names = this.git(['for-each-ref', '--format=%(refname)', prefix]).split('\n').filter(Boolean).map(r => r.slice(prefix.length))
-            .filter(n => ID_RE.test(n) && n !== 'main');
-        return names.sort();
+        const endpoint = this.h.endpoint;
+        return endpoint && this.rev('refs/heads/chat') ? [endpoint.name] : [];
     }
     // A control record: the room's genesis, or a root commit of Kind: room.
     isControl(room, sha, author, text) {
@@ -51,19 +45,29 @@ export class Branches extends Repo {
     }
     scan(room, tip, after) {
         const shas = this.git(['rev-list', '--topo-order', '--reverse', tip, '--not', after ?? `${room.genesis}^@`]).trim().split('\n').filter(Boolean);
+        let parent = after ?? this.rev(`${room.genesis}^`) ?? fail('room has no contract parent');
         return Remote.readCommits(this.h, shas).map(c => {
+            if (c.parents.length !== 1 || c.parents[0] !== parent)
+                fail('ALARM room chat is not one linear history');
+            parent = c.sha;
             const text = c.body.toString('utf8');
+            if (c.sha === room.genesis && (c.author !== ROOT || parse(text, x => this.isRef(x)).kind !== 'room'))
+                fail('ALARM room genesis is not a root control');
             return { sha: c.sha, parent: c.parents[0], author: c.author, text, control: this.isControl(room, c.sha, c.author, text) };
         });
     }
     room(name) {
+        if (!this.h.endpoint || this.h.endpoint.name !== name)
+            return null;
         const ref = this.ref(name);
         const tip = this.tip(name);
         if (!tip)
             return null;
         const genesis = this.git(['rev-list', '--first-parent', '--reverse', tip, '^refs/heads/main']).split('\n')[0]
             || this.git(['rev-list', '--first-parent', '--reverse', tip]).split('\n').filter(Boolean).at(-1);
-        if (this.trust === 'signed' && this.h.remoteAlarms?.[ref])
+        if (this.h.endpoint.genesis && genesis !== this.h.endpoint.genesis)
+            fail(`ALARM room ${name}: changed genesis`);
+        if (this.h.remoteAlarms?.[ref])
             fail(`ALARM ${this.h.remoteAlarms[ref]}; room ${name} is quarantined`);
         const control = this.entries({ name, genesis }, tip).filter(e => e.control).map(e => ({ rev: e.sha, text: e.text }));
         return { name, head: control.at(-1).rev, genesis, tip, base: this.rev(`${genesis}^`) ?? ZERO, control };
@@ -74,10 +78,14 @@ export class Branches extends Repo {
         return r.status === 0 ? r.stdout : null;
     }
     createRoom(name, who, text, files) {
-        const ref = `refs/heads/${name}`;
+        const ref = this.ref(name);
+        const endpoint = this.h.endpoint ?? fail('createRoom requires its explicit endpoint');
+        if (endpoint.name !== name)
+            fail('createRoom requires its named endpoint');
         if (this.rev(ref))
             fail(`room ${name} exists in hub ${this.d.name}`);
         const sha = this.commit(who, text, this.tree(null, Object.entries(files).map(([p, c]) => ({ path: p, content: c, mode: '100644' }))), [this.contractHead()]);
+        endpoint.genesis = sha;
         if (!this.advance(ref, sha, null))
             fail(`room ${name} was created meanwhile`);
         return sha;
@@ -92,20 +100,6 @@ export class Branches extends Repo {
     refsUnder(prefix) {
         return this.git(['for-each-ref', '--format=%(refname) %(objectname)', prefix]).split('\n').filter(Boolean).map(l => l.split(' '));
     }
-    // Every ref of the room in one transaction: its branch, every tag on its commits (signals, heartbeats,
-    // anyone's), what the store keeps under its genesis (pins, evidence) and its unpublished commits. Objects are left to
-    // the repository.
-    deleteRoom(room) {
-        const commits = this.commitsOf(room);
-        const tags = this.git(['for-each-ref', '--format=%(refname) %(objectname) %(*objectname)', 'refs/tags/']).split('\n').filter(Boolean)
-            .map(l => l.split(' ')).filter(([, object, target]) => commits.has(target || object)).map(([ref]) => ref);
-        const kept = this.refsUnder('refs/ringi/').map(([ref]) => ref).filter(ref => {
-            const [, , kind, key] = ref.split('/');
-            return key === room.genesis || (kind === 'unpublished' && commits.has(key));
-        });
-        const refs = [this.ref(room.name), ...tags, ...kept];
-        this.git(['update-ref', '--stdin'], { input: ['start', ...refs.map(r => `delete ${r}`), 'prepare', 'commit', ''].join('\n') });
-    }
     remote(room) {
         return { name: room.name, ref: this.ref(room.name), head: room.head, genesis: room.genesis };
     }

package/target/esm/adapters/{transport-git → store-git}/index.js

@@ -1,15 +1,7 @@
-// git-store: the Store port on git. The store directory holds one repository (`store/.git`):
-//   refs/heads/main                       the shared contract, one commit per amendment
-//   refs/heads/<room>                     the room: one linear branch, like a chat. Its first commit is the room's genesis
-//                                         (the root's, on top of main); then every message is a commit by its author, and
-//                                         every control record (Kind: room) a commit by the root
-//   refs/tags/<agent>.<signal>.<message12>   signals: annotated tags without text on the message's commit
-//   refs/ringi/accepted/<genesis>/<reader>/<author>   readers' pins of each author's accepted last message
-// A member's log is its own commits in the room's branch, in branch order. The control files at the root of a room's
-// tree (members, profile, signers) change only in the root's control records.
-// A signed hub signs every commit and tag with its author's key and verifies what it fetches (remote.ts).
-// The class is layered by concern: repo.ts (repository, contract), branches.ts (rooms), marks.ts (signals, heartbeats)
-// and here the logs: messages, their files, staging and pins.
+// Store on git/3: an explicit contract source or one self-contained room repository.
+// main holds the frozen contract; chat holds root controls and participant messages. Actor signals/telemetry are
+// append-only commit streams. Reader evidence lives below refs/ringi/accepted; message files remain in chat trees.
+// Signing is injected for every published commit. Repo, Branches and Marks separate storage from verification.
 import fs from 'node:fs';
 import path from 'node:path';
 import { fail } from '../../lib/index.js';
@@ -29,7 +21,7 @@ export class GitStore extends Marks {
         const { home, signing } = typeof connection === 'string' ? { home: connection, signing: undefined } : connection;
         if (d.trust === 'signed')
             signingContext({ name: d.name, signing });
-        const dir = path.join(hubDir, d.store.path, '.git');
+        const dir = path.join(hubDir, d.contract?.path ?? fail('no operator contract source'), '.git');
         // A signed hub's repository already exists: rootFor made it with the root key.
         if (!fs.existsSync(dir)) {
             mkdirIn(home, path.dirname(dir));
@@ -37,8 +29,7 @@ export class GitStore extends Marks {
         }
         const s = new GitStore(hubDir, d, home, signing);
         const sha = s.commit('operator', text, s.tree(null, Object.entries(contract).map(([p, c]) => ({ path: p, content: c, mode: '100644' }))), []);
-        if (d.trust === 'signed')
-            d.genesis = sha;
+        d.genesis = sha;
         if (!s.advance('refs/heads/main', sha, null))
             fail(`hub ${d.name}: main already exists`);
         s.checkout();
@@ -47,10 +38,10 @@ export class GitStore extends Marks {
     // A new signed hub: the root key is generated on this machine and pinned in the descriptor.
     static rootFor(hubDir, d, home, signing) {
         signingContext({ name: d.name, signing });
-        const dir = path.join(hubDir, d.store.path, '.git');
+        const dir = path.join(hubDir, d.contract?.path ?? fail('no operator contract source'), '.git');
         mkdirIn(home, path.dirname(dir));
         init(dir, home);
-        return Remote.setupSigned({ name: d.name, dir, d, signing }, d.store.remote).root;
+        return Remote.setupSigned({ name: d.name, dir, d, signing }, d.contract?.remote).root;
     }
     logIds(room) { return [...new Set(this.live(room).map(e => e.author))]; }
     logHead(room, id) { return this.live(room).filter(e => e.author === id).at(-1)?.sha ?? null; }
@@ -77,15 +68,6 @@ export class GitStore extends Marks {
         const id = this.git(['hash-object', '-w', '--', file]).trim();
         return { id, size: Number(this.git(['cat-file', '-s', id]).trim()) };
     }
-    // A tree of the staged files under refs/ringi/staged/<genesis>/<who>: git keeps what a ref reaches.
-    retain(room, who, entries) {
-        const ref = `refs/ringi/staged/${room.genesis}/${who}`;
-        if (!entries.length) {
-            this.gitOk(['update-ref', '-d', ref]);
-            return;
-        }
-        this.git(['update-ref', ref, this.tree(null, entries)]);
-    }
     // One message on top of the room's branch.
     append(room, who, text, entries) {
         if (checkOutgoing(text, s => this.isRef(s)).trailers['ringi-files'])
@@ -104,10 +86,10 @@ export class GitStore extends Marks {
         return this.trust === 'signed' ? Remote.verify(this.h, this.remote(room), id, head) : null;
     }
     pin(room, reader, id, rev) {
-        this.git(['update-ref', `refs/ringi/accepted/${room.genesis}/${reader}/${id}`, rev]);
+        this.git(['update-ref', `refs/ringi/accepted/${room.genesis}/${reader}/logs/${id}`, rev]);
     }
     unpin(room, reader, id) {
-        this.gitOk(['update-ref', '-d', `refs/ringi/accepted/${room.genesis}/${reader}/${id}`]);
+        this.gitOk(['update-ref', '-d', `refs/ringi/accepted/${room.genesis}/${reader}/logs/${id}`]);
     }
     file(rev, p) { return runGitRaw(this.args(['show', `${rev}:${p}`]), this.home); }
     sizes(rev, paths) {

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

@@ -0,0 +1,86 @@
+// Signals and telemetry: one append-only stream per actor in the selected room repository.
+import { Branches } from './branches.js';
+import { fail } from '../../lib/index.js';
+import { streamName, streamRef, scanStream, signalEvents } from './remote/streams.js';
+import { heartbeatBody } from './remote/heartbeat-facts.js';
+import { push } from './remote/push.js';
+export class Marks extends Branches {
+    streamAlarms = new Map();
+    scannedStreams = new Map();
+    streams(_room, kind) {
+        return this.refsUnder('refs/heads/').flatMap(([ref, head]) => {
+            const s = streamName(ref);
+            return s?.kind === kind ? [{ actor: s.actor, head }] : [];
+        });
+    }
+    readStream(room, actor, kind, head) {
+        const ref = streamRef(actor, kind);
+        const chat = this.tip(room.name) ?? fail('room chat is missing');
+        const cached = this.scannedStreams.get(ref);
+        if (cached?.seen === head && cached.chat === chat)
+            return cached.stream;
+        const prefix = cached && this.extends(cached.chat, chat) && this.extends(cached.stream.head, head) ? cached.stream : undefined;
+        const s = scanStream({ H: this.h, R: this.remote(room), actor, kind, head, prefix });
+        // Telemetry has no domain fold: keep only its latest valid facts in this handle, without pruning Git history.
+        if (kind === 'telemetry')
+            s.records = s.records.slice(-1);
+        this.scannedStreams.set(ref, { seen: head, chat, stream: s });
+        if (s.why)
+            this.streamAlarms.set(ref, `signal stream ${actor}: ${s.why}; stopped at ${s.head.slice(0, 12)}`);
+        else
+            this.streamAlarms.delete(ref);
+        return s;
+    }
+    signalHeads(room) { return this.streams(room, 'signals'); }
+    signals(room) {
+        return this.streams(room, 'signals').flatMap(({ actor, head }) => signalEvents(this.remote(room), actor, this.readStream(room, actor, 'signals', head)));
+    }
+    pinSignals(room, reader, actor, head) {
+        streamRef(actor, 'signals');
+        this.git(['update-ref', `refs/ringi/accepted/${room.genesis}/${reader}/signals/${actor}`, head]);
+    }
+    alarms(room) { return [...super.alarms(room), ...this.streamAlarms.values()]; }
+    appendStream(room, who, kind, body, tuple) {
+        const ref = streamRef(who, kind);
+        for (let attempt = 0; attempt < 8; attempt++) {
+            const current = this.room(room.name) ?? fail(`room ${room.name} is gone`);
+            const old = this.rev(ref);
+            let prefix;
+            if (old) {
+                const checked = this.readStream(current, who, kind, old);
+                prefix = checked;
+                if (checked.why || checked.head !== old)
+                    fail(`ALARM ${ref}: ${checked.why ?? 'unaccepted dependencies'}; nothing appended`);
+                if (tuple && checked.records.some(r => r.fields.get('Target') === tuple.target && r.fields.get('Signal') === tuple.signal)) {
+                    push(this.h, ref);
+                    return old;
+                }
+            }
+            const parent = old ?? room.genesis;
+            const tree = this.git(['rev-parse', `${parent}^{tree}`]).trim();
+            const sha = this.commit(who, body(current.head), tree, [parent]);
+            const checked = scanStream({ H: this.h, R: this.remote(current), actor: who, kind, head: sha, prefix });
+            if (checked.why || checked.head !== sha)
+                fail(checked.why ?? 'stream dependencies are not accepted');
+            if (this.advance(ref, sha, old))
+                return sha;
+        }
+        return fail(`${ref} kept moving; retry`);
+    }
+    signal(room, who, target, signal) {
+        this.appendStream(room, who, 'signals', control => `Room: ${room.genesis}\nControl: ${control}\nTarget: ${target}\nSignal: ${signal}\n`, { target, signal });
+    }
+    heartbeat(room, who, target, text) {
+        const body = /^Room:/m.test(text) ? text : `${text.trimEnd()}\nRoom: ${room.genesis}\n`;
+        if (heartbeatBody(body) !== room.genesis)
+            fail('heartbeat names another room');
+        return this.appendStream(room, who, 'telemetry', control => `${body.trimEnd()}\nControl: ${control}\nTarget: ${target}\n`);
+    }
+    heartbeats(room) {
+        return this.streams(room, 'telemetry').flatMap(({ actor, head }) => {
+            const latest = this.readStream(room, actor, 'telemetry', head).records.at(-1);
+            return latest ? [{ agent: actor, target: latest.fields.get('Target'), time: latest.raw.time, text: latest.raw.text }] : [];
+        });
+    }
+}
+//# sourceMappingURL=marks.js.map

package/target/esm/adapters/{transport-git → store-git}/remote/commits.js

@@ -19,7 +19,9 @@ export const readCommits = (H, shas) => {
         const parents = [...hdr.matchAll(/^parent ([0-9a-f]+)$/gm)].map(m => m[1]);
         const author = /^author (.*?) <[^>\n]*> \d+ [+-]\d{4}$/m.exec(hdr)?.[1] ?? '';
         const message = split < 0 ? Buffer.alloc(0) : body.subarray(split + 2);
-        return { sha, parents, author, body: message, text: P.decodeText(message).text ?? '' };
+        const committer = /^committer (.*?) <[^>\n]*> (\d+) [+-]\d{4}$/m.exec(hdr);
+        const tree = /^tree ([0-9a-f]+)$/m.exec(hdr)?.[1] ?? '';
+        return { sha, parents, author, committer: committer?.[1] ?? '', time: Number(committer?.[2]), tree, body: message, text: P.decodeText(message).text ?? '' };
     });
 };
 //# sourceMappingURL=commits.js.map

package/target/esm/adapters/{transport-git → store-git}/remote/git.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import * as C from '../../../lib/index.js';
 import * as FS from '../../fs/index.js';
 import * as P from '../../../core/hub/protocol/index.js';
+import { storeOf } from '../../../core/hub/rooms/address.js';
 import { withVerification } from './cache.js';
 import { BASE, command } from './process.js';
 import { ACCEPT, TRACK } from './types.js';
@@ -32,7 +33,13 @@ export const isRemote = (H) => {
         C.fail(`unsupported hub trust ${String(H.d.trust)}`);
     return H.d.trust === 'signed';
 };
-export const origin = (H) => H.d.store.remote;
+export const origin = (H) => {
+    const address = H.endpoint ? H.endpoint.store.remote : H.d.contract?.remote;
+    if (!address)
+        return undefined;
+    const { type, locator } = storeOf(address);
+    return type === 'git' ? locator : C.fail(`git cannot open a ${type} address`);
+};
 export const suffix = (ref) => ref.replace(/^refs\/heads\//, '');
 export const accepted = (ref) => ACCEPT + suffix(ref);
 export const tracking = (ref) => TRACK + suffix(ref);