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

# Close a Hug

> The requester ends its Hug with its outcome; later answers are refused. Closing again changes nothing. Only the daemon that opened the Hug may close it.

Daemon push: requires the daemon's realm token (`cliq_dt_…`) for the realm that owns the hug given by `hug_id`.



## OpenAPI

````yaml /openapi/hub-by-tag/hub-hugs.yaml post /v1/hugs/close
openapi: 3.0.3
info:
  title: 'CliqHub API: Hugs'
  version: 1.0.0
  description: >-
    A Hug is a run asking people for input: an agent (a review gate, or its own
    `ctx.ask`) opens

    one with a prompt, context (markdown, files, check results, an earlier
    conversation) and the

    inputs it needs — text, number, boolean, a choice, a file, a channel.
    CliqHub posts it to the

    Hug's channels; anyone it reaches who can view runs in the realm answers on
    the Hug page, and

    can change their answer while it is open. Every answer is sent back to the
    agent, which decides

    when it has heard enough and closes the Hug; it expires after its time (at
    most 7 days).


    Seeing a Hug needs `runs.view` on its realm; answering also needs the Hug to
    be addressed to

    you (your own channel, or one of its shared channels). `create`, `close` and
    `get_events` are

    for daemons only.
servers:
  - url: https://{host}
    variables:
      host:
        default: cliqhub.io
        description: CliqHub host
security: []
tags:
  - name: Hugs
    description: >-
      A Hug is a run asking people for input: an agent (a review gate, or its
      own `ctx.ask`) opens

      one with a prompt, context (markdown, files, check results, an earlier
      conversation) and the

      inputs it needs — text, number, boolean, a choice, a file, a channel.
      CliqHub posts it to the

      Hug's channels; anyone it reaches who can view runs in the realm answers
      on the Hug page, and

      can change their answer while it is open. Every answer is sent back to the
      agent, which decides

      when it has heard enough and closes the Hug; it expires after its time (at
      most 7 days).


      Seeing a Hug needs `runs.view` on its realm; answering also needs the Hug
      to be addressed to

      you (your own channel, or one of its shared channels). `create`, `close`
      and `get_events` are

      for daemons only.
paths:
  /v1/hugs/close:
    post:
      tags:
        - Hugs
      summary: Close a Hug
      description: >-
        The requester ends its Hug with its outcome; later answers are refused.
        Closing again changes nothing. Only the daemon that opened the Hug may
        close it.


        Daemon push: requires the daemon's realm token (`cliq_dt_…`) for the
        realm that owns the hug given by `hug_id`.
      operationId: POST_v1_hugs_close
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                hug_id:
                  type: string
                  minLength: 1
                  description: The Hug.
                outcome:
                  type: string
                  maxLength: 2
                  description: How it ended, in words (shown on the Hug page).
                daemon_id:
                  type: string
                  minLength: 1
                  description: >-
                    The daemon closing it — the one that opened it, and a daemon
                    of the token's realm.
              required:
                - hug_id
                - outcome
                - daemon_id
            examples:
              default:
                value:
                  hug_id: 6c2d1e0f-9a8b-4c7d-8e6f-5a4b3c2d1e0f
                  outcome: Approved
                  daemon_id: 7d1c2b3a-4e5f-4a6b-8c7d-9e0f1a2b3c4d
      responses:
        '200':
          description: Success.
          content:
            application/json:
              schema:
                type: object
                required:
                  - ok
                  - data
                properties:
                  ok:
                    type: boolean
                    enum:
                      - true
                    description: Always `true` on success.
                  data:
                    type: object
                    properties:
                      status:
                        type: string
              example:
                ok: true
                data:
                  status: closed
        '401':
          description: >-
            `unauthorized`: No `Authorization` header, or the token is
            malformed, expired or revoked.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                unauthorized:
                  summary: unauthorized
                  value:
                    ok: false
                    error:
                      code: unauthorized
                      message: Authentication required
        '403':
          description: >-
            `forbidden`: You can see the record but your role in its realm is
            too low or lacks the required permission.


            `forbidden`: Another daemon opened this Hug.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                forbidden:
                  summary: forbidden
                  value:
                    ok: false
                    error:
                      code: forbidden
                      message: You do not have access to do this
                forbidden (endpoint):
                  summary: forbidden (endpoint)
                  value:
                    ok: false
                    error: Only the daemon that opened this Hug may close it
                    code: forbidden
        '404':
          description: >-
            `not_found`: The record does not exist or is in a realm you cannot
            see (404 rather than 403, so its existence is not revealed).


            `not_found`: No Hug has this id.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                not_found:
                  summary: not_found
                  value:
                    ok: false
                    error:
                      code: not_found
                      message: Not found
                not_found (endpoint):
                  summary: not_found (endpoint)
                  value:
                    ok: false
                    error: Hug not found
                    code: not_found
        '422':
          description: >-
            `invalid_params`: The body fails the request schema: a required
            field is missing or a value has the wrong type or format. The
            message lists every issue as `field: problem`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                invalid_params:
                  summary: invalid_params
                  value:
                    ok: false
                    error: 'hug_id: Required'
                    code: invalid_params
        '500':
          description: >-
            `internal_error`: An unexpected server fault. Retry later; if it
            persists, report it with the time of the request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HubErr'
              examples:
                internal_error:
                  summary: internal_error
                  value:
                    ok: false
                    error: Internal server error
                    code: internal_error
      security:
        - BearerAuth: []
components:
  schemas:
    HubErr:
      type: object
      required:
        - ok
        - error
      description: >-
        Every failure. Route-policy denials (401/403/404, and 400 when neither
        realm_id nor org_id was sent) answer `error` as `{ code, message }`;
        errors raised by the endpoint answer `error` as the message with the
        code beside it in `code`. Every error has a code. See
        [Errors](/hub-api/errors).
      properties:
        ok:
          type: boolean
          description: Always false on error
        error:
          description: The message, or `{ code, message }` for an access denial.
          oneOf:
            - type: string
            - type: object
              required:
                - code
                - message
              properties:
                code:
                  type: string
                message:
                  type: string
        code:
          type: string
          description: Stable error code of an endpoint error.
        details:
          type: object
          additionalProperties: true
          description: Structured detail, when there is some.
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: cliq_tok_* | cliq_dt_*
      description: >-
        User PAT (`cliq_tok_…`, including session-scoped) or realm token
        (`cliq_dt_…`).

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.