continuity.sync

Fetches the remote's refs/majordomus/continuity, merges it into the local store as the union of both (records are content-addressed, so a name holding different bytes is reported and the local copy kept), and pushes the result, never forced. Reports each line as equal, remote_newer, local_newer, diverged, local_only or remote_only. An unreachable remote changes nothing and leaves what is pending pending.

command
experimental
module continuity
#continuity
#handover
#devices

Exposure

Where this one definition is reachable. Absence is explicit: a surface not listed does not carry it.

surface	as
MCP	tool majordomus_continuity_sync
HTTP	POST /api/v1/continuity/sync operationId continuity.sync
command line	majordomus continuity sync

Schemas

The canonical input and output, from the Rust types; the MCP tool schema and the OpenAPI parameters and responses are derived from these.

input · SyncInput

The input of continuity.sync.

property	type	required	description
remote	string \| null	no	The git remote; the current branch's, else `origin`, when absent.

JSON Schema

{
  "additionalProperties": false,
  "description": "The input of `continuity.sync`.",
  "properties": {
    "remote": {
      "description": "The git remote; the current branch's, else `origin`, when absent.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "title": "SyncInput",
  "type": "object"
}

output · Synced

The answer of continuity sync.

property	type	required	description
action	reference	yes	What happened.
diagnostics	array	yes	Refused files, collisions, diverged lines, an unreachable remote.
fetched	integer	yes	Records the local store gained.
lines	array	yes	Every line either side holds, compared.
published	integer	yes	Records the remote gained.
remote	string \| null	no	The remote, when there is one.
resumable	array	yes	What other devices published that this checkout could resume.
store	reference	yes	The store after the sync.

JSON Schema

{
  "$defs": {
    "Device": {
      "description": "The device a record was written on: the mesh node key's id and the label its identity\nfile carries. The label is presentation; the node id is identity.",
      "properties": {
        "label": {
          "description": "The display label of the device's identity file (`macbook-pro`), or the first eight\nhex of its node id when it has none.",
          "type": "string"
        },
        "node": {
          "description": "The node id: the first 32 hex of the SHA-256 of the device's Ed25519 public key.",
          "type": "string"
        }
      },
      "required": [
        "node",
        "label"
      ],
      "type": "object"
    },
    "Diagnostic": {
      "description": "One finding about the declarative state, named by a stable code, tied to a path where\nthere is one, and carrying the command that reproduces it where there is one.",
      "properties": {
        "code": {
          "description": "A stable machine-readable code, e.g. `unknown_key`, `duplicate_identity`.",
          "type": "string"
        },
        "message": {
          "description": "What is wrong, for a person; the code is for a program.",
          "type": "string"
        },
        "path": {
          "description": "Repository-relative path of the file concerned, when there is one.",
          "type": [
            "string",
            "null"
          ]
        },
        "severity": {
          "$ref": "#/$defs/Severity",
          "description": "How bad."
        }
      },
      "required": [
        "severity",
        "code",
        "message"
      ],
      "type": "object"
    },
    "LineSync": {
      "description": "How the local store and a remote's stand towards each other, for one line.",
      "oneOf": [
        {
          "const": "equal",
          "description": "Both hold the same heads.",
          "type": "string"
        },
        {
          "const": "remote_newer",
          "description": "The remote holds records that continue the local heads: fetching brings them.",
          "type": "string"
        },
        {
          "const": "local_newer",
          "description": "The local store holds records that continue the remote's: publishing sends them.",
          "type": "string"
        },
        {
          "const": "diverged",
          "description": "Each holds a continuation the other lacks: after merging, the line has two heads.",
          "type": "string"
        },
        {
          "const": "local_only",
          "description": "Only the local store holds the line.",
          "type": "string"
        },
        {
          "const": "remote_only",
          "description": "Only the remote holds the line.",
          "type": "string"
        }
      ]
    },
    "LineSyncView": {
      "description": "One line's comparison in a sync.",
      "properties": {
        "heads": {
          "description": "The line's heads after the merge.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "line": {
          "description": "The line.",
          "type": "string"
        },
        "relation": {
          "$ref": "#/$defs/LineSync",
          "description": "How the local store and the remote's stood before the merge."
        }
      },
      "required": [
        "line",
        "relation",
        "heads"
      ],
      "type": "object"
    },
    "RecordView": {
      "description": "One record as every surface shows it.",
      "properties": {
        "age_minutes": {
          "description": "Minutes since then, by this machine's clock; absent when either clock's reading is\nunusable.",
          "format": "int64",
          "type": [
            "integer",
            "null"
          ]
        },
        "branch": {
          "description": "The branch it was written on.",
          "type": [
            "string",
            "null"
          ]
        },
        "changed_total": {
          "description": "How many paths differed from HEAD at the origin.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "device": {
          "$ref": "#/$defs/Device",
          "description": "The device that published it."
        },
        "head": {
          "description": "The commit it was written at.",
          "type": [
            "string",
            "null"
          ]
        },
        "id": {
          "description": "The record id.",
          "type": "string"
        },
        "issue": {
          "description": "The issue.",
          "type": [
            "string",
            "null"
          ]
        },
        "line": {
          "description": "Its line.",
          "type": "string"
        },
        "objective": {
          "description": "The handover's `# Objective`, first line.",
          "type": "string"
        },
        "parent": {
          "description": "The record it continues.",
          "type": [
            "string",
            "null"
          ]
        },
        "published_at": {
          "description": "When it was published, by the publisher's clock.",
          "type": "string"
        },
        "session": {
          "description": "The episode it was published from.",
          "type": [
            "string",
            "null"
          ]
        },
        "task": {
          "description": "The task's title: the intent.",
          "type": [
            "string",
            "null"
          ]
        },
        "this_device": {
          "description": "Whether that device is this one.",
          "type": "boolean"
        },
        "trust": {
          "$ref": "#/$defs/Trust",
          "description": "Whether its signer is trusted here."
        },
        "working_tree": {
          "$ref": "#/$defs/WorkingTree",
          "description": "Clean or dirty at the origin."
        }
      },
      "required": [
        "id",
        "line",
        "device",
        "this_device",
        "trust",
        "working_tree",
        "changed_total",
        "published_at"
      ],
      "type": "object"
    },
    "Severity": {
      "description": "How bad a diagnostic is. `Error` excludes the file it concerns from the index and puts\nthe index into the degraded state; `Warning` and `Info` do neither.",
      "oneOf": [
        {
          "const": "info",
          "description": "Worth knowing; changes nothing.",
          "type": "string"
        },
        {
          "const": "warning",
          "description": "Something to look at; the object is still served.",
          "type": "string"
        },
        {
          "const": "error",
          "description": "The file is excluded and the index is degraded.",
          "type": "string"
        }
      ]
    },
    "StoreView": {
      "description": "The two stores, as refs.",
      "properties": {
        "records": {
          "description": "Records admitted.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "reference": {
          "description": "The local ref.",
          "type": "string"
        },
        "refused": {
          "description": "Files refused.",
          "format": "uint",
          "minimum": 0,
          "type": "integer"
        },
        "remote": {
          "description": "The remote `sync` uses.",
          "type": [
            "string",
            "null"
          ]
        },
        "remote_tip": {
          "description": "The commit last fetched from or pushed to it.",
          "type": [
            "string",
            "null"
          ]
        },
        "sync": {
          "$ref": "#/$defs/SyncState",
          "description": "How they stand."
        },
        "tip": {
          "description": "Its commit.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "reference",
        "sync",
        "records",
        "refused"
      ],
      "type": "object"
    },
    "SyncAction": {
      "description": "What a sync did.",
      "oneOf": [
        {
          "const": "none",
          "description": "Nothing to move: both held the same records.",
          "type": "string"
        },
        {
          "const": "fetched",
          "description": "Records were fetched.",
          "type": "string"
        },
        {
          "const": "published",
          "description": "Records were published.",
          "type": "string"
        },
        {
          "const": "exchanged",
          "description": "Both.",
          "type": "string"
        },
        {
          "const": "unreachable",
          "description": "The remote could not be reached; nothing local changed, and what is pending stays\npending.",
          "type": "string"
        },
        {
          "const": "no_remote",
          "description": "No remote is configured.",
          "type": "string"
        }
      ]
    },
    "SyncState": {
      "description": "How the local store stands towards the remote's, from the refs alone — no network.",
      "oneOf": [
        {
          "const": "no_remote",
          "description": "No remote is configured: the store is local, and that is a valid answer.",
          "type": "string"
        },
        {
          "const": "never_synced",
          "description": "Never synced with the remote.",
          "type": "string"
        },
        {
          "const": "in_sync",
          "description": "Both hold the same records.",
          "type": "string"
        },
        {
          "const": "pending",
          "description": "This store holds records the remote has not received: a sync publishes them.",
          "type": "string"
        },
        {
          "const": "behind",
          "description": "The last fetch brought records not merged yet.",
          "type": "string"
        },
        {
          "const": "diverged",
          "description": "Both of the above.",
          "type": "string"
        },
        {
          "const": "empty",
          "description": "The store is empty and nothing was ever fetched.",
          "type": "string"
        }
      ]
    },
    "Trust": {
      "description": "Whether the device that signed a record is one this repository trusts.",
      "oneOf": [
        {
          "const": "this_device",
          "description": "This device signed it.",
          "type": "string"
        },
        {
          "const": "trusted",
          "description": "The mesh declaration's trust list admits the key.",
          "type": "string"
        },
        {
          "const": "untrusted",
          "description": "The mesh declaration exists and does not admit the key: never resumed from.",
          "type": "string"
        },
        {
          "const": "undeclared",
          "description": "The repository declares no mesh, so no list exists to check the key against. The\nsignature still binds the record to its key; the plan warns.",
          "type": "string"
        }
      ]
    },
    "WorkingTree": {
      "description": "Whether the working tree had changes git does not hold in a commit.",
      "oneOf": [
        {
          "const": "clean",
          "description": "Nothing outside HEAD.",
          "type": "string"
        },
        {
          "const": "dirty",
          "description": "Modified, staged or untracked files that HEAD does not hold.",
          "type": "string"
        }
      ]
    }
  },
  "description": "The answer of `continuity sync`.",
  "properties": {
    "action": {
      "$ref": "#/$defs/SyncAction",
      "description": "What happened."
    },
    "diagnostics": {
      "description": "Refused files, collisions, diverged lines, an unreachable remote.",
      "items": {
        "$ref": "#/$defs/Diagnostic"
      },
      "type": "array"
    },
    "fetched": {
      "description": "Records the local store gained.",
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "lines": {
      "description": "Every line either side holds, compared.",
      "items": {
        "$ref": "#/$defs/LineSyncView"
      },
      "type": "array"
    },
    "published": {
      "description": "Records the remote gained.",
      "format": "uint",
      "minimum": 0,
      "type": "integer"
    },
    "remote": {
      "description": "The remote, when there is one.",
      "type": [
        "string",
        "null"
      ]
    },
    "resumable": {
      "description": "What other devices published that this checkout could resume.",
      "items": {
        "$ref": "#/$defs/RecordView"
      },
      "type": "array"
    },
    "store": {
      "$ref": "#/$defs/StoreView",
      "description": "The store after the sync."
    }
  },
  "required": [
    "action",
    "fetched",
    "published",
    "lines",
    "store",
    "resumable",
    "diagnostics"
  ],
  "title": "Synced",
  "type": "object"
}

Policies

benchmark: waived — waived: external_dependency
cache: disabled — every call runs the handler

Benchmark targets

Derived from the registry for this repository: one requirement per transport, and the cases the input type provides. The whole matrix is on the benchmarks page.

transport	state	cases	targets
direct	waived (external_dependency)	0
mcp	waived (external_dependency)	0
http	waived (external_dependency)	0