---
slug: rooms/info
version: "0.5"
extends: "0.4"
title: Rooms — Info
summary: "A member asks a room's host what it holds about the room — tier, epoch, retention and last prune, signal delay, file limits, the largest record and file chunk it accepts, and the room's and member's usage — authorized by the room's own credentials."
status: draft
targetFrameworkVersion: "0.6.0"
category: access-control
keywords:
  - room
  - quota
  - limits
  - usage
  - storage
  - record size
  - chunk size
parties:
  - role: Member
    requirement: REQUIRED
    member: issuer
    identifierScope: pairwise
  - role: Host
    requirement: REQUIRED
    member: recipient
proofRequirement:
  requirement: REQUIRED
  rationale: "Authority is the room-issued chain in the payload, whose leaf must be the party the host authenticated. A room operation carries no session, so that party is the proof's signer and nothing else: without a proof there is nobody to bind the chain to, and the presentation becomes a bearer token. The same rule as every other rooms/* task."
sideEffects:
  level: none
  rationale: "Reads the host's record of the room and its usage counters. Persists nothing."
subjectPath: /roomId
exposure:
  discloses: metadata
  ingests: none
  actsAsSubject: false
  rationale: "Discloses, to a member, the room's tier, epoch, record retention, latest prune, file limits and the record and chunk sizes the host accepts, the room's total use, and the member's own use and allowance — hosting metadata the host holds by construction. Never another member's figures, and nothing derived from content."
retention:
  class: transient
  rationale: "A read; the host keeps nothing beyond what it held already."
errorCodes:
  - code: rooms/info:chainTooDeep
    meaning: "The authority chain exceeds the maximum of 8 links."
    retryable: false
  - code: rooms/info:subjectBindingMissing
    meaning: "A `private` room presentation omitted the required same-subject proof."
    retryable: false
related:
  - rooms/usage
  - rooms/records/prune
  - rooms/records/retention/set
  - rooms/signal-delay/set
  - rooms/changed
  - rooms/blobs/upload/begin
  - rooms/records/put
  - rooms/blobs/upload/chunk
  - vtc/rooms/limits/set
---

## Abstract

A data room's host decides how much it is willing to store for the room: whether the room
may hold files at all, how large one may be, how many and how much in total, for the room
and for each member in it. A member needs those numbers **before** an upload — to be told
that a file will not fit, and by which limit, rather than finding out halfway through a
transfer — and needs to see how much of their own allowance they have spent.

The **Rooms — Info** Trust Task returns them: the room's tier and current epoch, the limits
the host applies to it, the room's total usage, and the asking member's own usage and
effective allowance. Like every task in the `rooms/*` family, it is authorized by a
presentation of credentials the room issued, never by an account at the host.

Version 0.2 adds how long the room keeps its records — its `recordRetention`, which says
which records [`rooms/records/prune`](../../records/prune/0.2/spec.md) may remove — and the
room's `lastPrune`. Every member who may read a room can read the rule its records are removed
under, before any is.

Version 0.4 adds the room's `signalDelay`: whether the host waits a randomised interval before
sending the room's [`rooms/changed`](../../changed/0.1/spec.md) signals, as set by
[`rooms/signal-delay/set`](../../signal-delay/set/0.1/spec.md).

Version 0.5 adds the two sizes a client needs before it writes, so it can refuse locally rather
than learn from a refusal: `maxRecordDocumentBytes`, the largest
[`rooms/records/put`](../../records/put/0.6/spec.md) document the host accepts, and
`maxChunkSize`, the largest chunk it takes in a proxied file transfer at its own size. With the
file limits and the member's allowance this task already returns, a client can tell from one
read whether a message fits in a record, whether a file fits in the room, and how to cut it.

## Status of this Document

This is a **draft** *Trust Task specification* per [SPEC.md §5.3](/SPEC.md#53-maturity-levels); the schema **MAY** change without notice. Feedback via the [issue tracker](https://github.com/trustoverip/dtgwg-trust-tasks-tf/issues).

### What changed from 0.1

Two optional response members, `recordRetention` and `lastPrune` ([`RecordRetention`,
`RecordPrune`](../../_shared/0.2/room.schema.json)). The response is a closed object, so a 0.1
reader would refuse them; a new member on a closed payload is a `MINOR` increment per
[SPEC §5.2](/SPEC.md#52-compatibility-rules). A host that implements 0.2 **SHOULD** continue
to answer 0.1, without them.

## Changes from 0.4

Two optional response members:

* **`maxRecordDocumentBytes`** — the largest `rooms/records/put` request document the host
  accepts for this room, measured as `maxDocumentBytes` measures it ([SPEC §12.4](/SPEC.md#124-parser-hardening)):
  the serialized document as received, `proof` and `presentation` included.
* **`maxChunkSize`** ([`ChunkSize`](../../../vta/_shared/0.1/backup-transfer.schema.json)) —
  the largest `chunks.chunkSize` the host accepts for this room's proxied transfers without
  refusing the chunk or charging it to a stricter budget.

Both answer questions a client could otherwise settle only by reading a host's source or by being
refused. [`rooms/records/put/0.6`](../../records/put/0.6/spec.md) declares a bound every host
serving it accepts — 2,097,152 bytes — but a host may keep a smaller per-record limit of its own,
refused with `recordTooLarge`, and before `0.6` there was no declared bound at all, so one host
stored a record another refused. Chunk documents are bounded at 360,448 bytes by
[`rooms/blobs/upload/chunk/0.2`](../../blobs/upload/chunk/0.2/spec.md), but a host whose
transport admits large documents under a tighter budget than small ones has, in effect, a smaller
chunk size, and a client cutting 256 KiB chunks against it uploads at a fraction of the rate it
expected without being told why.

The file limits and the per-member allowance a client also needs are not new: `limits`
(`RoomLimits` — whether files are enabled, the largest file, how many and how much in total, for the
room and per member) and `usage.member.limits` (the asking member's own effective allowance) have
been in the response since 0.1.

The request is unchanged, and the response only gains optional members, so 0.5 declares
`extends: "0.4"`: a host implementing only 0.4 answers a 0.5 request as 0.4, and its answer simply
lacks both members — which a client reads as "no limit of the host's own", the declared bounds
governing. A host that implements 0.5 **SHOULD** continue to answer 0.4.

## Changes from 0.3

* A required response member, **`signalDelay`** ([`SignalDelay`](../../_shared/0.2/room.schema.json)): `randomised` or `none`, `randomised` for a room that has never set one. It is always present so that a member never has to guess which is in force from its absence.

The response is a closed object, so a 0.3 reader would refuse the new member; a new member on a closed payload is a `MINOR` increment per [SPEC §5.2](/SPEC.md#52-compatibility-rules). A host that implements 0.4 **SHOULD** continue to answer 0.3, without it. The request is unchanged.

## Changes from 0.2

* The shared `RecordPrune` member (response `lastPrune`) **`at`** → **`prunedAt`**. Same type (`string`, `date-time`, required) and meaning.

The rename brings this member into line with the registry's naming convention — an instant that records an event is named `<event>At` — so the same concept has one spelling across the registry. All of the schema's `$ref`s into `rooms/_shared/0.1/room.schema.json` move to `rooms/_shared/0.2/room.schema.json`, which differs from 0.1 only by this rename; nothing else in the payload moves.

Breaking on the wire, released as a `MINOR` increment under [§5.2](/SPEC.md#52-compatibility-rules)'s `draft` allowance. `0.2` remains published.

## Conformance

[[RFC2119]](https://www.rfc-editor.org/rfc/rfc2119) and [[RFC8174]](https://www.rfc-editor.org/rfc/rfc8174) key-word conventions apply.

A conforming **host** (`recipient`) **MUST**:

1. Verify the presentation exactly as [`rooms/records/get`](../../records/get/0.2/spec.md)
   does — every link of the chain, at most 8, no link widening its parent, no parent
   dereferenced, the leaf bound to the party authenticated for this request, and on a
   `private` room a `subjectBinding` — and require that it confer `read` at this room's
   scope.
2. Return the room's **effective** limits: an administrator's override for the room where
   one exists, else the room's limits at creation, with every byte measure capped by the
   host-wide ceiling. A limit the host would not actually enforce **MUST NOT** be reported.
3. Return `usage.room` from the same counters an upload is checked against, reservations
   included, so a member who sees room for a file is not then refused for lack of it.
4. On `open` and `attributed` rooms, return `usage.member` for the **subject at the root of
   the presented chain** — the member, not the agent or key that signed — with the limits
   that apply to that member in this room.
5. On a `private` room, **omit** `usage.member`. The host does not know which member is
   asking, and the tier exists so that it cannot.
6. Return `recordRetention` exactly as in force — set at `rooms/create` 0.2 or since by
   `rooms/records/retention/set` — and omit it when there is none. **MUST NOT** report a
   retention it would not apply, or omit one it would.
7. Return `lastPrune` when the room's records have been pruned, as the latest
   `rooms/records/prune` left it, and omit it otherwise.
8. Return `signalDelay` as the one it applies to the room's `rooms/changed` signals — set at
   `rooms/create` 0.3 or since by `rooms/signal-delay/set`, else `randomised`. **MUST NOT** report `randomised` for a room whose
   signals it sends without a wait, since a member reading it would believe the room keeps a
   protection it does not.
9. Return `maxRecordDocumentBytes` when it applies a per-record limit of its own below the bound
   the newest `rooms/records/put` version it serves declares, as that limit — the size at which it
   refuses a write with `recordTooLarge` — and **MAY** return it otherwise, as that declared
   bound. It **MUST NOT** return a value above the declared bound, or one it does not enforce: a
   client that trusted a larger figure would sign writes the host then refuses, and one that
   trusted a smaller figure would split records it had no need to.
10. Return `maxChunkSize` when it admits proxied chunks larger than some size only under a budget
   stricter than the room's transfer budget, or refuses them, as the largest size it admits under
   that budget; and **MAY** return it otherwise, as 262,144. It **MUST NOT** return a size the
   transfer ceiling does not admit.
11. **Never** return another member's figures, a list of members, or anything derived from
   record or file content.

## Authorization

A presentation that does not confer `read` at this room's scope, whose chain does not reach the room, or whose leaf is not the party the host authenticated, is refused with the standard `permissionDenied` ([SPEC §8.3](/SPEC.md#83-standard-error-codes)); this specification declares no task-specific code for it.

Authority is **conferred by the room**: the presentation must confer `read` at this room's
scope. The host's own access control is neither required nor consulted — a community
administrator reads hosting figures for every room through the host's own operator task
([`vtc/rooms/usage`](../../../vtc/rooms/usage/0.1/spec.md)), not through this one.

## Choosing a record size and a chunk size

A client about to write a record **SHOULD** compare the serialized document it is about to send
with `maxRecordDocumentBytes` where present, and with the bound its `rooms/records/put` version
declares where not, and carry content that would not fit as a file
([`rooms/blobs/upload/begin`](../../blobs/upload/begin/0.2/spec.md)). For the record body
alone it **SHOULD** leave room for the presentation and proof, which on a deep authority chain
run to tens of KiB.

A client about to upload a file through the host **SHOULD** choose a `chunks.chunkSize` no larger
than `maxChunkSize` where present. The bound is on the chunk; the chunk *document* carries it
base64url-encoded with its envelope and proof, and `rooms/blobs/upload/chunk/0.2` bounds that
document at 360,448 bytes, which a 262,144-byte chunk fits. A direct transfer
(`TransferMode` `direct`) moves no chunk documents and is not bound by `maxChunkSize`.

## Definitions

- **Limits**, **usage**, **scope** — as in
  [`rooms/_shared/0.1/blobs.schema.json`](../../_shared/0.1/blobs.schema.json):
  `RoomLimits`, `ScopeLimits`, `Usage`. All sizes are ciphertext bytes, padding included —
  what is actually stored.
- **Effective member limits** — the limits a member's upload is checked against at the
  member scope: an override set for that member in this room if there is one, else the
  room's per-member default.
- **Record document** — a `rooms/records/put` request document, serialized as sent: the JSON
  text, `proof` and `presentation` included, no transport envelope. The measure `maxDocumentBytes`
  uses ([SPEC §12.4](/SPEC.md#124-parser-hardening)), because it is the one a host can count
  before it parses.
- **Root subject** — the subject of the credential at the room end of the authority chain;
  usage is charged to it so that a member cannot multiply their allowance by minting agents.

## Request

A member (`issuer`) asks the room's host (`recipient`). The payload is the top-level schema
in [`payload.schema.json`](payload.schema.json).

### A member checks the room before adding a file

```json
{
  "id": "urn:uuid:5b1d8c2e-6a4f-4f0e-9c3b-2a7d1e0f4a01",
  "type": "https://trusttasks.org/spec/rooms/info/0.5#request",
  "issuer": "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK",
  "recipient": "did:web:rooms.northwind.example",
  "issuedAt": "2026-10-10T09:29:00Z",
  "threadId": "urn:uuid:5b1d8c2e-6a4f-4f0e-9c3b-2a7d1e0f4aff",
  "payload": {
    "roomId": "did:webvh:QmRoom:rooms.northwind.example:deal",
    "presentation": {
      "membership": "eyJhbGciOiJFZERTQSJ9.membership.sig",
      "authority": [
        "eyJhbGciOiJFZERTQSJ9.authority-root.sig"
      ]
    }
  }
}
```

## Response

The host answers with the sub-schema reachable via `$anchor: "response"` in
[`payload.schema.json`](payload.schema.json). Failures use `trust-task-error`.

### An `attributed` room, with the member's own figures

This host keeps a per-record limit of 64 KiB below the 2 MiB `rooms/records/put/0.6` declares,
and takes chunks at the full transfer ceiling.

```json
{
  "id": "urn:uuid:5b1d8c2e-6a4f-4f0e-9c3b-2a7d1e0f4a02",
  "type": "https://trusttasks.org/spec/rooms/info/0.5#response",
  "issuer": "did:web:rooms.northwind.example",
  "recipient": "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK",
  "issuedAt": "2026-10-10T09:29:01Z",
  "threadId": "urn:uuid:5b1d8c2e-6a4f-4f0e-9c3b-2a7d1e0f4aff",
  "payload": {
    "roomId": "did:webvh:QmRoom:rooms.northwind.example:deal",
    "visibility": "attributed",
    "epoch": 7,
    "recordRetention": { "tombstoneDays": 30, "recordDays": 730 },
    "lastPrune": { "version": 118, "prunedAt": "2026-10-01T00:00:05Z", "removed": 14 },
    "signalDelay": "randomised",
    "maxRecordDocumentBytes": 65536,
    "maxChunkSize": 262144,
    "limits": {
      "filesEnabled": true,
      "room": { "maxFiles": 10000, "maxFileBytes": 104857600, "maxBytes": 5368709120 },
      "member": { "maxFiles": 2000, "maxFileBytes": 104857600, "maxBytes": 1073741824 }
    },
    "usage": {
      "room": { "files": 312, "bytes": 1288490188, "reservedBytes": 4718880, "reservedFiles": 1 },
      "member": {
        "usage": { "files": 41, "bytes": 209600000, "reservedBytes": 0 },
        "limits": { "maxFiles": 2000, "maxFileBytes": 104857600, "maxBytes": 209715200 }
      }
    }
  }
}
```

## Security & Privacy

**Room authorization only.** This task is answered from the room's credentials, so it works
against any host that stores the room, and a host that answers it from an account of its own
has made itself part of the membership.

**The member's figures are the member's.** `usage.member` describes the root subject of the
chain that was presented and nobody else. Returning another member's usage would turn a
read every member may make into a census of who adds what, which on `attributed` is the
room owner's to see ([`rooms/usage`](../../usage/0.1/spec.md)) and on `private` is nobody's.

**Reported limits are enforced limits.** A member decides whether to upload from these
numbers. A host reporting a limit it does not enforce — higher or lower — makes the
member's client wrong in a way the member cannot detect. The same holds for the record and chunk
sizes: they are hosting configuration, the same for every member of the room, and say nothing
about any member or any content.

### Data carried

In: a room identifier and a presentation, which names the member on `open` and `attributed`
rooms and only proves membership on `private`. Out: tier, epoch, record retention, the latest
prune's version, time and count, the signal delay, limits and counts, and the record and chunk
sizes the host accepts — no record, no record key, no file name,
no member list.

### Correlation

On `open` and `attributed`, the host learns that this member looked, and when — as it learns
for every read. On `private`, only that some member did. The response itself carries
nothing about other members.

### Retention

Nothing new is stored. Hosts that log reads keep what they keep for every read.

### Consent/purpose

The member asks about a room they belong to, for the purpose of using it. The figures are
the host's own operating data about storage it provides; nothing personal is disclosed
beyond the member's own use, to the member.
