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

# Resolve a conflict

> Apply one of the four human-in-the-loop resolutions. Every resolution is non-destructive
and reversible via the revert endpoint: losing memories are marked `stale` and kept
in the store.




## OpenAPI

````yaml /openapi.yaml post /memory/conflicts/{id}/resolve
openapi: 3.1.0
info:
  title: memloom local API
  version: 0.1.0
  description: >
    The HTTP API served by the `memloom serve` daemon on your machine. The CLI,
    the MCP server,

    and the viewer all route through this API, so every client shares one
    consistent view of

    your memories.


    ## Owners


    One daemon can serve more than one owner. Every owner-scoped endpoint, reads
    as well as

    writes, acts for the owner named by the `X-Memloom-Owner` request header: a
    uuid, sent on

    every request by a client bound to that owner. A request without the header
    gets the

    daemon's own default owner (`MEMLOOM_OWNER_ID` in its environment, or the
    sentinel owner

    when that is unset), which is what a single-owner install has always used
    and what the

    browser-based Console gets. `GET /health` reports that default.


    A malformed header is refused with 400 rather than coerced. The three
    endpoints that also

    accept an `ownerId` in their body (`/memory/save`, `/context/add`,
    `/context/url`) refuse a

    body value that disagrees with the header, rather than silently preferring
    one.


    Store-wide endpoints carry no owner: the speech-model catalog, reconcile
    settings, the

    connector scopes, the ingest queue, and `/health`.


    No authentication: the daemon binds to `127.0.0.1` only and is reachable
    solely from your

    own machine. Browser clients on other localhost ports are allowed via CORS.
    The owner header

    is therefore a separation mechanism, not an authentication one: any process
    on your machine

    can name any owner. It keeps two agents or two people out of each other's
    memories; it is

    not a boundary between untrusted users.
servers:
  - url: http://127.0.0.1:4319
    description: Local memloom daemon
security: []
paths:
  /memory/conflicts/{id}/resolve:
    post:
      summary: Resolve a conflict
      description: >
        Apply one of the four human-in-the-loop resolutions. Every resolution is
        non-destructive

        and reversible via the revert endpoint: losing memories are marked
        `stale` and kept

        in the store.
      operationId: resolveConflict
      parameters:
        - $ref: '#/components/parameters/OwnerHeader'
        - name: id
          in: path
          required: true
          schema:
            type: string
          description: The conflict id from the save response or the conflicts list.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ResolveDecision'
      responses:
        '200':
          description: Resolution applied.
          content:
            application/json:
              schema:
                type: object
                properties:
                  ok:
                    type: boolean
                    example: true
        '400':
          $ref: '#/components/responses/ValidationError'
        '404':
          $ref: '#/components/responses/NoSuchConflict'
components:
  parameters:
    OwnerHeader:
      name: X-Memloom-Owner
      in: header
      required: false
      description: >
        The owner this request acts for. Applies to every owner-scoped endpoint,
        reads as well

        as writes. Omit it and the daemon's own default owner answers (see `GET
        /health`), which

        is what a single-owner install has always used. A value that is not a
        uuid is refused

        with 400 rather than coerced.
      schema:
        type: string
        format: uuid
      example: 11111111-1111-4111-8111-111111111111
  schemas:
    ResolveDecision:
      oneOf:
        - type: object
          title: keep_new
          required:
            - action
          properties:
            action:
              type: string
              enum:
                - keep_new
              description: The new memory wins; existing candidates go stale.
        - type: object
          title: keep_existing
          required:
            - action
            - candidateId
          properties:
            action:
              type: string
              enum:
                - keep_existing
            candidateId:
              type: string
              description: The existing memory that wins; the new one goes stale.
        - type: object
          title: keep_both
          required:
            - action
          properties:
            action:
              type: string
              enum:
                - keep_both
              description: Mark them distinct; both stay active.
        - type: object
          title: merge
          required:
            - action
            - content
          properties:
            action:
              type: string
              enum:
                - merge
            content:
              type: string
              description: The reconciled memory text that supersedes both.
            canonical:
              type: string
  responses:
    ValidationError:
      description: The request body failed validation. `issues` names each offending field.
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                example: invalid request body
              issues:
                type: array
                items:
                  type: object
                  properties:
                    path:
                      type: string
                      example: query
                    message:
                      type: string
                      example: query must be a non-empty string
    NoSuchConflict:
      description: >
        No conflict with that id belongs to this owner. Deliberately the same
        answer whether the

        conflict is another owner's or does not exist at all: which of the two
        it is, is itself

        another owner's business.
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                example: 'memloom: no conflict 8b1f0c0e-4f2a-4f1b-9a6e-2f0a1c7d3b55'

````

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