> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lerian.studio/llms.txt
> Use this file to discover all available pages before exploring further.

# List the shared sessions this home holds

> The RECIPIENT's end of publishing: the conversations colleagues have published to this home, newest first.
IT IS ADDRESSED BY SHARE ID AND NOT BY SESSION ID, here and on every road of this group. A published copy is not a session at this home: the entries arrived redacted from somebody else's machine and no session of that id exists here, by design. The session id a row reports is provenance about the machine it came from, and asking this host about it answers nothing.
WHO MAY SEE WHAT IS DECIDED HERE AND NOT BY A CLIENT. A share published to the whole organisation is readable by any member of it, which is every actor this home admits — one organisation is one home. A share naming colleagues is readable by exactly those colleagues and by whoever published it. This page is that rule asked once per row: the shares a caller may not read are simply absent, because a listing that refused would show a person nothing rather than their own.
A page can therefore come back shorter than its limit, and the cursor still leads where it led: a client pages until nextCursor is absent.
Shares whose expiry has passed and shares somebody revoked are not here. The conversation they carried has been deleted and the record survives only to say who had read it.



## OpenAPI

````yaml /es/openapi/v3-current/narya.yaml get /v1/shares
openapi: 3.1.0
info:
  title: Narya Host API
  version: 1.0.0
  description: >-
    The contract between the Narya host and every client. One long-lived host
    serves this API over a Unix socket in your Narya home. The terminal client
    and the one-shot command that Lerian ships drive this API, and a client you
    write drives the same one.


    Requests authenticate with a bearer token issued by the identity provider
    the host is configured with. An operation that declares another security
    scheme also accepts that credential. A request without a valid credential
    gets 401 with NRY-0011. A caller whose role lacks the permission an
    operation needs gets 403 with NRY-0028.


    Submitting a message returns 202 with a turn id. Everything the turn
    produces streams over GET /v1/events as server-sent events with a typed
    envelope, and a stream resumes from a Last-Event-ID header.


    One error envelope: code, title and message. Codes are NRY- followed by four
    digits. Cursors are opaque.
servers: []
security:
  - bearerAuth: []
tags:
  - name: host
    description: The host process itself — version, uptime, mode, store.
  - name: sessions
    description: Durable conversation containers. Archive, never destroy.
  - name: messages
    description: Submitting work into a session and interrupting it.
  - name: events
    description: The server-sent event stream every client consumes.
  - name: lanes
    description: Parallel tracks inside a session — main, subagent, side.
  - name: agents
    description: Named recipes — instructions, tools, model, policy. Read-only in v1.
  - name: ladder
    description: >-
      What a person can type: the skills and command files in force for one
      repository, and expanding one into text. Five origins merged, nearest
      winning a name, the repository's own rungs gated on trust.
  - name: permissions
    description: Pending permission asks, decisions, and the decision audit.
  - name: intercom
    description: Sessions on one machine finding and messaging each other.
  - name: packages
    description: The one thing a user installs — resources, Go code, or both.
  - name: extensions
    description: >-
      Host-side extensions and the operations each exposes over the wire. This
      is the generic lane a host extension uses to serve its own client half (a
      TUI component, a web panel) or any API-only consumer, without adding
      routes to this contract.
  - name: workflows
    description: Deterministic multi-agent orchestration runs.
  - name: providers
    description: Model suppliers, their auth state, and the model catalogue.
  - name: monitors
    description: >-
      Long-running watchers a session keeps beside its conversation — a test
      runner in watch mode, a build, a log being followed. Started by the model
      or by the person, always listed, always killable.
  - name: records
    description: The queryable local record of everything that happened.
  - name: environments
    description: >-
      Where a session's code lives and its commands run — this machine, or a
      container narya operates. A session that names none runs here.
  - name: schedules
    description: >-
      Work the host's own clock starts with nobody present — a repository, a
      prompt, a rule and what one fire may spend. Cancel, never destroy.
  - name: sharing
    description: >-
      Publishing a session from a developer's own home to the organisation's,
      and what is held back before a byte leaves the machine.
  - name: refinements
    description: >-
      What this owner has taught narya and allowed it to keep — distilled facts,
      and the skills, agents and commands the model wrote for itself. Propose,
      read, consent, roll back. Nothing here fires until a person answers.
  - name: platform
    description: >-
      Calls Lerian's control plane made to a home it hosts, as this home
      recorded them.
paths:
  /v1/shares:
    get:
      tags:
        - sharing
      summary: List the shared sessions this home holds
      description: >-
        The RECIPIENT's end of publishing: the conversations colleagues have
        published to this home, newest first.

        IT IS ADDRESSED BY SHARE ID AND NOT BY SESSION ID, here and on every
        road of this group. A published copy is not a session at this home: the
        entries arrived redacted from somebody else's machine and no session of
        that id exists here, by design. The session id a row reports is
        provenance about the machine it came from, and asking this host about it
        answers nothing.

        WHO MAY SEE WHAT IS DECIDED HERE AND NOT BY A CLIENT. A share published
        to the whole organisation is readable by any member of it, which is
        every actor this home admits — one organisation is one home. A share
        naming colleagues is readable by exactly those colleagues and by whoever
        published it. This page is that rule asked once per row: the shares a
        caller may not read are simply absent, because a listing that refused
        would show a person nothing rather than their own.

        A page can therefore come back shorter than its limit, and the cursor
        still leads where it led: a client pages until nextCursor is absent.

        Shares whose expiry has passed and shares somebody revoked are not here.
        The conversation they carried has been deleted and the record survives
        only to say who had read it.
      operationId: listReceivedShares
      parameters:
        - $ref: '#/components/parameters/CursorParam'
        - $ref: '#/components/parameters/LimitParam'
      responses:
        '200':
          description: One page of the shares this home holds for this caller.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ReceivedSharePage'
        '400':
          $ref: '#/components/responses/BadRequest'
        '500':
          $ref: '#/components/responses/InternalServerError'
components:
  parameters:
    CursorParam:
      name: cursor
      in: query
      required: false
      description: >-
        Opaque pagination cursor from a previous page's nextCursor or
        prevCursor.
      schema:
        type: string
        maxLength: 1024
    LimitParam:
      name: limit
      in: query
      required: false
      description: Maximum items per page.
      schema:
        type: integer
        minimum: 1
        maximum: 100
        default: 25
  schemas:
    ReceivedSharePage:
      type: object
      description: >-
        One page of the shared sessions this home holds for whoever is asking,
        newest first.

        THE PAGE CAN BE SHORTER THAN ITS LIMIT. The audience rule is asked once
        per row and the rows a caller may not read are left out, so a page's
        length says nothing about whether there is another: a client pages until
        nextCursor is absent.
      required:
        - items
        - limit
      properties:
        items:
          type: array
          items:
            $ref: '#/components/schemas/ReceivedShare'
        nextCursor:
          type: string
          description: >-
            Pass as `cursor` for the next page. Absent when this home holds
            nothing older.
        limit:
          type: integer
          minimum: 1
          description: The page size this host applied.
    ReceivedShare:
      type: object
      description: >-
        One shared session as the home that RECEIVED it holds it.

        It is not SessionShare read from the other end, and the difference is
        which home is speaking. What a publishing home records is what it sent
        and what it still owes; what this records is what ARRIVED — so the
        instant on it is when this home took the first delivery, and the
        position on it is how far the copy here reaches rather than how far a
        delivery has been acknowledged.

        THERE IS NO ORGANISATION ON IT, deliberately. One organisation is one
        home: this home is stamped with the organisation it serves and refuses a
        token for any other before a handler runs, so the organisation a share
        belongs to is the organisation asking.
      required:
        - shareId
        - sessionId
        - publisher
        - mode
        - state
        - receivedAt
        - throughSeq
      properties:
        shareId:
          type: string
          minLength: 26
          maxLength: 26
          pattern: ^[A-Z2-7]{26}$
          description: >-
            The share's id, which is how this copy is addressed here and
            everywhere else. It carries no encoding of anything, so it discloses
            nothing about the session or the machine it came from.
        sessionId:
          type: string
          format: uuid
          description: >-
            The session this was published FROM, at the home it was published
            from. It is provenance and nothing more: no session with this id
            exists here, none is created, and asking this host about it answers
            nothing.
        publisher:
          type: string
          description: >-
            The subject of whoever published it, read off the verified token
            that carried the first delivery and never off a payload. It is an
            identifier and not a display name: names are the identity provider's
            to answer and would go stale here.
        mode:
          type: string
          enum:
            - once
            - sync
          description: >-
            Where the publish stops, so a reader knows whether more of this
            conversation is still coming.
        state:
          type: string
          enum:
            - pending
            - active
            - revoked
          description: >-
            How far it has got. On this road it is always `active`: a revoked
            share and one whose expiry has passed answer 404, because the
            conversation they carried has been deleted and confirming that such
            a share ever existed is itself a disclosure. The field carries the
            full enum so a client holds one vocabulary for a share at either
            home.
        receivedAt:
          type: string
          format: date-time
          description: >-
            When THIS home took the first delivery, by this home's own clock. It
            is deliberately not when the person asked for the share: the
            publishing machine's clock is not a fact this home can vouch for,
            and what a reader here asks is when the organisation received it.
        expiresAt:
          type: string
          format: date-time
          description: >-
            When this copy stops and is deleted, carried from the publishing
            home so this home enforces it by its own clock. A share whose expiry
            has passed is closed whether or not the sweep has been round yet —
            which is why `state` has no `expired` value.

            Absent for a share with no expiry, which nothing this product
            publishes produces.
        throughSeq:
          type: integer
          format: int64
          minimum: 0
          description: >-
            How far into the conversation this home reaches, in the publishing
            home's own numbering — the sequence of the last entry held. It is
            the same number the last row of a read of the entries carries, and
            the number share-received announces, so a client can tell "there is
            more" from "I already have this" without a request.
      examples:
        - shareId: K7QX2ZM4YB6PWNRJ5TFHCDA3EV
          sessionId: 6b9f6d2e-1c3a-4f5b-9d7e-2a8c4e6f0b1d
          publisher: user_ada
          mode: sync
          state: active
          receivedAt: '2026-09-08T09:16:00.000Z'
          expiresAt: '2026-10-08T09:15:00.000Z'
          throughSeq: 42
    Error:
      type: object
      description: >-
        The single error envelope every operation returns. Codes are NRY-
        followed by four digits and are catalogued in the top-level
        x-error-catalog extension.
      required:
        - code
        - title
        - message
      properties:
        code:
          type: string
          pattern: ^NRY-[0-9]{4}$
          description: Machine-readable error code from the NRY catalogue.
        title:
          type: string
          maxLength: 256
          description: Short human-readable summary of the error class.
        message:
          type: string
          maxLength: 4096
          description: Specific, actionable description of what went wrong.
        fields:
          type: object
          description: Per-field validation problems.
          additionalProperties:
            type: string
      examples:
        - code: NRY-0002
          title: Session not found
          message: >-
            No session with id 6b9f6d2e-1c3a-4f5b-9d7e-2a8c4e6f0b1d exists on
            this host.
  responses:
    BadRequest:
      description: Malformed request — invalid parameter, cursor, or JSON body.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    InternalServerError:
      description: The host failed — including a store that refuses writes (NRY-0012).
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: >-
        Enforced on every transport, with no exempt operation. A person's
        request — over the default local unix socket exactly as over a TCP
        listener — must carry a JWT issued by the configured identity provider,
        which the host verifies itself against that issuer's key set: signature,
        issuer, expiry, and the person and organisation it names. Requests
        without a valid one receive 401 NRY-0011. The socket's file permissions
        are transport and are not an authorisation.

````