@claudexor/schema 4.3.1 → 4.5.0

package/generated/ControlRunEventPart.schema.json

@@ -0,0 +1,140 @@
+{
+  "$ref": "#/definitions/ControlRunEventPart",
+  "definitions": {
+    "ControlRunEventPart": {
+      "type": "object",
+      "properties": {
+        "runId": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Canonical run id."
+        },
+        "seq": {
+          "type": "integer",
+          "exclusiveMinimum": 0,
+          "maximum": 9007199254740991,
+          "description": "Durable seq of the event (its event-stream id)."
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "run.created",
+            "task.contract.created",
+            "context.pack.created",
+            "project.git.initialized",
+            "project.claude_bridge.created",
+            "budget.lease.created",
+            "budget.observation",
+            "budget.cash",
+            "policy.web.upgraded",
+            "harness.started",
+            "harness.event",
+            "harness.completed",
+            "route.fallback.started",
+            "route.fallback.completed",
+            "route.fallback.exhausted",
+            "route.transient.detected",
+            "route.transient.retry_scheduled",
+            "route.profile.headroom_exceeded",
+            "route.profile.rotated",
+            "route.profile.rotation_exhausted",
+            "route.profile.credential_unusable",
+            "route.account.pool_selected",
+            "route.account.lane_switch",
+            "route.account.pool_exhausted",
+            "route.transient.exhausted",
+            "route.fallback.auth_switched",
+            "route.primary.diverged",
+            "route.pool.degraded",
+            "session.continuity",
+            "interaction.requested",
+            "interaction.answered",
+            "interaction.timeout",
+            "interaction.answer_discarded",
+            "interaction.withdrawn",
+            "message.accepted",
+            "message.delivered",
+            "message.refused",
+            "plan.progress",
+            "plan.questions",
+            "plan.brief.materialized",
+            "council.started",
+            "council.draft",
+            "council.member.failed",
+            "council.merged",
+            "budget.quota_pressure",
+            "delegation.belt.unavailable",
+            "delegation.belt.degraded",
+            "output.ready",
+            "gate.started",
+            "gate.completed",
+            "review.preflight",
+            "review.started",
+            "review.skipped",
+            "reviewer.started",
+            "reviewer.first_event",
+            "reviewer.auth_switched",
+            "reviewer.completed",
+            "reviewer.timed_out",
+            "reviewer.failed",
+            "finding.revalidated",
+            "synthesis.started",
+            "arbitration.completed",
+            "work_product.emitted",
+            "work_product.adopted",
+            "control.requested",
+            "control.applied",
+            "control.rejected",
+            "run.blocked",
+            "run.completed",
+            "run.failed",
+            "run.continuation",
+            "run.continuation.denied",
+            "run.continuity",
+            "workspace.retained"
+          ],
+          "description": "Type of an append-only run event, covering run lifecycle, contract/context creation, budget, routing fallbacks, harness activity, interactions, gates, review, arbitration, work products, and control verbs."
+        },
+        "totalBytes": {
+          "type": "integer",
+          "exclusiveMinimum": 0,
+          "description": "UTF-8 byte length of the event's complete stream serialization: the redacted JSON line the run event stream delivers."
+        },
+        "sha256": {
+          "type": "string",
+          "pattern": "^[0-9a-f]{64}$",
+          "description": "SHA-256 of all totalBytes; verify the reassembled text before parsing it."
+        },
+        "offset": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 9007199254740991,
+          "description": "UTF-8 byte offset where this part starts."
+        },
+        "nextOffset": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 9007199254740991,
+          "description": "Where the next part starts; equal to totalBytes when this part ends the event."
+        },
+        "text": {
+          "type": "string",
+          "description": "Bytes [offset, nextOffset) decoded as UTF-8; a boundary never splits a character."
+        }
+      },
+      "required": [
+        "runId",
+        "seq",
+        "type",
+        "totalBytes",
+        "sha256",
+        "offset",
+        "nextOffset",
+        "text"
+      ],
+      "additionalProperties": false,
+      "description": "One bounded part of a single validated run event, read from the run's own event log by run id and seq. Concatenate parts in offset order until nextOffset equals totalBytes; only then is the event consumed."
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/generated/GlobalConfig.schema.json

@@ -313,7 +313,7 @@
               "type": "integer",
               "minimum": 0,
               "default": 20,
-              "description": "The newest N runs per project always survive, regardless of age."
+              "description": "The newest N runs survive for active registrations (even with missing roots), archived registrations whose roots exist, and the built-in no-project scope. Orphaned namespaces have no keep-last protection."
             }
           },
           "additionalProperties": false,

package/generated/ImageCallRequest.schema.json

@@ -52,7 +52,7 @@
               "additionalProperties": false
             }
           ],
-          "description": "Auto keeps a usable prior account; pin never selects another account."
+          "description": "Auto text operations prefer preferredProfileId among unmarked accounts of the same catalog tier (listed before unlisted); a listed alternative, a mark or a recent refusal outranks it. History bound to that account keeps it first over a catalog miss only while it has neither a mark nor a recent refusal. Image operations order accounts by the pool alone. Pin never selects another account."
         },
         "prompt": {
           "type": "string",

package/generated/McpAccountsToolResult.schema.json

@@ -381,6 +381,72 @@
             "routingEvidence": {
               "type": "object",
               "properties": {
+                "capabilities": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "harness_id": {
+                        "type": "string",
+                        "minLength": 1,
+                        "description": "Harness family of the account."
+                      },
+                      "profile_id": {
+                        "type": "string",
+                        "minLength": 1,
+                        "description": "Account row that refused this model before generation started."
+                      },
+                      "requested_model": {
+                        "type": "string",
+                        "description": "Model the refused request named."
+                      },
+                      "account_fingerprint": {
+                        "type": [
+                          "string",
+                          "null"
+                        ],
+                        "description": "Provider account identity the mark is bound to; null when the adapter has none."
+                      },
+                      "provider_reason": {
+                        "type": "string",
+                        "description": "Latest refusal diagnostic, redacted and at most 1024 characters: the provider's reason for a recognized refusal, the engine's message and vendor code otherwise."
+                      },
+                      "observed_at": {
+                        "type": "string",
+                        "minLength": 1,
+                        "description": "Start of this mark's episode, when its row was created (a recognized refusal, or the service elsewhere that confirmed an unrecognized one); renewals and probes keep it."
+                      },
+                      "expires_at": {
+                        "type": "string",
+                        "minLength": 1,
+                        "description": "Probe becomes eligible at this time; not a vendor reset."
+                      },
+                      "state": {
+                        "type": "string",
+                        "enum": [
+                          "provisional",
+                          "confirmed",
+                          "probe_due",
+                          "probing"
+                        ],
+                        "description": "provisional = refused here; confirmed = another account then served the correlated retry; probe_due = expired, the next selection may probe it; probing = one operation holds that probe."
+                      }
+                    },
+                    "required": [
+                      "harness_id",
+                      "profile_id",
+                      "requested_model",
+                      "account_fingerprint",
+                      "provider_reason",
+                      "observed_at",
+                      "expires_at",
+                      "state"
+                    ],
+                    "additionalProperties": false,
+                    "description": "A temporary capability mark for one account and one model. It only orders auto selection: the account stays enabled and usable as a last fallback."
+                  },
+                  "description": "Temporary capability marks; absent from engines that predate them. A mark clears on a success there or a catalog or credential change; after expires_at one operation may probe the account."
+                },
                 "refusals": {
                   "type": "array",
                   "items": {

package/generated/McpRunEventReadInput.schema.json

@@ -0,0 +1,41 @@
+{
+  "$ref": "#/definitions/McpRunEventReadInput",
+  "definitions": {
+    "McpRunEventReadInput": {
+      "type": "object",
+      "properties": {
+        "runId": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 256
+        },
+        "seq": {
+          "type": "integer",
+          "exclusiveMinimum": 0,
+          "maximum": 9007199254740991,
+          "description": "The event to read, e.g. claudexor_run_wait's oversizedEvent.seq."
+        },
+        "offset": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 9007199254740991,
+          "default": 0,
+          "description": "0, or the previous part's nextOffset."
+        },
+        "maxBytes": {
+          "type": "integer",
+          "minimum": 4,
+          "maximum": 65536,
+          "default": 32768,
+          "description": "Upper bound of this part's UTF-8 bytes; a part may end earlier at a character boundary."
+        }
+      },
+      "required": [
+        "runId",
+        "seq"
+      ],
+      "additionalProperties": false
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/generated/McpRunHandleResult.schema.json

@@ -1667,6 +1667,388 @@
           "description": "Typed Delegate receipt; null when unavailable or legacy.",
           "default": null
         },
+        "continueFrom": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/McpRunHandleResult/properties/attemptExecution/items/properties/attemptId"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Predecessor run this run continues; null for an ordinary run, omitted when the detail did not project it."
+        },
+        "resumable": {
+          "anyOf": [
+            {
+              "type": "object",
+              "properties": {
+                "cause": {
+                  "type": "string",
+                  "enum": [
+                    "vendor_limit",
+                    "pool_exhausted",
+                    "pinned_limit",
+                    "transport",
+                    "permission_denied",
+                    "context_exhausted",
+                    "wall_clock",
+                    "cancelled",
+                    "host_restart",
+                    "input_required",
+                    "other"
+                  ],
+                  "description": "Typed reason the previous process stopped: a vendor limit (next account eligible), the whole pool spent, a pinned account's limit, a transport death (crash, timeout, watchdog), a confirmed native tool permission refusal, context exhaustion, the wall-clock deadline, a cancel, a daemon/host restart, a model that asked for input, or another typed cause."
+                },
+                "resetsAt": {
+                  "type": [
+                    "string",
+                    "null"
+                  ],
+                  "description": "When the spent vendor window reopens, only from a vendor signal; never fabricated."
+                },
+                "limitWindow": {
+                  "type": [
+                    "string",
+                    "null"
+                  ],
+                  "description": "The vendor's own name for the spent window (e.g. five_hour, seven_day_opus), when known."
+                },
+                "limitEvidence": {
+                  "anyOf": [
+                    {
+                      "type": "string",
+                      "enum": [
+                        "window",
+                        "unspecified"
+                      ],
+                      "description": "window: the vendor named the spent window (a reset instant or a constraint id); unspecified: a typed limit without a window — a bare backoff frame is transport, not a limit."
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "description": "window: the vendor named the spent window (a reset instant or a constraint id); unspecified: a typed limit without a window — a bare backoff frame is transport, not a limit."
+                },
+                "carriers": {
+                  "type": "array",
+                  "items": {
+                    "type": "string",
+                    "enum": [
+                      "native",
+                      "native_moved",
+                      "packet"
+                    ],
+                    "description": "A continuity representation still available for a stopped run."
+                  },
+                  "description": "Continuity representations still available (NOT quota readiness; readiness is described by the limit facts)."
+                },
+                "limitCode": {
+                  "type": [
+                    "string",
+                    "null"
+                  ],
+                  "description": "The typed vendor limit code that ended the work, when any."
+                },
+                "session": {
+                  "anyOf": [
+                    {
+                      "type": "object",
+                      "properties": {
+                        "harness": {
+                          "$ref": "#/definitions/McpRunHandleResult/properties/attemptExecution/items/properties/attemptId"
+                        },
+                        "nativeSessionId": {
+                          "type": "string",
+                          "minLength": 1
+                        },
+                        "holderProfileId": {
+                          "anyOf": [
+                            {
+                              "$ref": "#/definitions/McpRunHandleResult/properties/attemptExecution/items/properties/attemptId"
+                            },
+                            {
+                              "type": "null"
+                            }
+                          ],
+                          "description": "Non-empty identifier string."
+                        }
+                      },
+                      "required": [
+                        "harness",
+                        "nativeSessionId",
+                        "holderProfileId"
+                      ],
+                      "additionalProperties": false
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "description": "The native session a continuation can resume, when one exists."
+                },
+                "workspace": {
+                  "type": "object",
+                  "properties": {
+                    "kind": {
+                      "type": "string",
+                      "enum": [
+                        "in_place",
+                        "retained_envelope",
+                        "none"
+                      ]
+                    },
+                    "root": {
+                      "type": [
+                        "string",
+                        "null"
+                      ]
+                    }
+                  },
+                  "required": [
+                    "kind",
+                    "root"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Where the stopped work's tree is: the live root, a retained envelope, or gone."
+                }
+              },
+              "required": [
+                "cause",
+                "resetsAt",
+                "limitWindow",
+                "limitEvidence",
+                "carriers",
+                "limitCode",
+                "session",
+                "workspace"
+              ],
+              "additionalProperties": false,
+              "description": "Terminal facts of a stopped run that can be continued: cause, limit evidence, available carriers, the native session and the workspace."
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Terminal facts of stopped unfinished work that claudexor_run_continue can continue (cause, resetsAt, carriers, session, workspace); null when the work finished or the run is not terminal, omitted when not projected."
+        },
+        "continuity": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "tryIndex": {
+                "type": "integer",
+                "minimum": 0,
+                "description": "Native try within the attempt; joins the receipt to its try."
+              },
+              "attemptId": {
+                "$ref": "#/definitions/McpRunHandleResult/properties/attemptExecution/items/properties/attemptId"
+              },
+              "carrier": {
+                "type": "string",
+                "enum": [
+                  "native",
+                  "native_moved",
+                  "packet",
+                  "fresh"
+                ],
+                "description": "Carrier of a continued try: native (the vendor's own session, same account), native_moved (the session file made visible in the next account's store, then resumed there), packet (a fresh session re-grounded by an evidence index), or fresh (nothing to carry — a replay of the original prompt)."
+              },
+              "cause": {
+                "$ref": "#/definitions/McpRunHandleResult/properties/resumable/anyOf/0/properties/cause"
+              },
+              "from": {
+                "type": "object",
+                "properties": {
+                  "runId": {
+                    "$ref": "#/definitions/McpRunHandleResult/properties/attemptExecution/items/properties/attemptId"
+                  },
+                  "attemptId": {
+                    "$ref": "#/definitions/McpRunHandleResult/properties/attemptExecution/items/properties/attemptId"
+                  },
+                  "profileId": {
+                    "anyOf": [
+                      {
+                        "$ref": "#/definitions/McpRunHandleResult/properties/attemptExecution/items/properties/attemptId"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ],
+                    "description": "Non-empty identifier string."
+                  }
+                },
+                "required": [
+                  "runId",
+                  "attemptId",
+                  "profileId"
+                ],
+                "additionalProperties": false
+              },
+              "to": {
+                "type": "object",
+                "properties": {
+                  "profileId": {
+                    "anyOf": [
+                      {
+                        "$ref": "#/definitions/McpRunHandleResult/properties/attemptExecution/items/properties/attemptId"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ],
+                    "description": "Non-empty identifier string."
+                  }
+                },
+                "required": [
+                  "profileId"
+                ],
+                "additionalProperties": false
+              },
+              "workspace": {
+                "type": "string",
+                "enum": [
+                  "same_root",
+                  "different_root"
+                ],
+                "description": "Whether the continued try runs in the predecessor's execution root."
+              },
+              "memory": {
+                "type": "string",
+                "enum": [
+                  "full",
+                  "partial",
+                  "unknown"
+                ],
+                "description": "Its own fact: a native resume carries the whole history (full); a packet re-brief is partial; a native resume that lost history (e.g. a rejected compacted item) is partial/unknown."
+              },
+              "instructions": {
+                "type": "string",
+                "enum": [
+                  "as_sent",
+                  "vendor_snapshot"
+                ],
+                "description": "as_sent: the successor's instructions equal the predecessor's; vendor_snapshot: they differ, and the vendor may resend its recorded system prompt instead (claude records it on the first request)."
+              },
+              "reingestedTokens": {
+                "anyOf": [
+                  {
+                    "type": "integer",
+                    "minimum": 0
+                  },
+                  {
+                    "type": "null"
+                  }
+                ],
+                "description": "Input + cache-creation tokens of the first resumed request, when known."
+              },
+              "observedModel": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "THIS try's attested model (never borrowed from another try)."
+              },
+              "modelMismatch": {
+                "type": [
+                  "boolean",
+                  "null"
+                ]
+              },
+              "identityCheck": {
+                "type": "string",
+                "enum": [
+                  "matched_before_effects",
+                  "mismatch_before_effects",
+                  "mismatch_after_possible_effects",
+                  "not_applicable"
+                ],
+                "description": "Whether the resumed vendor session was the one requested, judged at the earliest handshake (codex thread/resume before turn/start; claude system/init): matched, mismatch caught before the child could act, mismatch caught after it may have acted, or not applicable (no resume was requested, or a harness without the continuity capability answered with another session id, which is recorded as before)."
+              },
+              "inputDelivery": {
+                "type": "string",
+                "enum": [
+                  "confirmed",
+                  "uncertain",
+                  "not_applicable"
+                ],
+                "description": "Whether the predecessor's last input (its turn prompt or an admitted steering message) is known to be in the vendor history: confirmed, uncertain (carried in the notice as a reference to reconcile, never replayed blindly), or not applicable."
+              }
+            },
+            "required": [
+              "tryIndex",
+              "attemptId",
+              "carrier",
+              "cause",
+              "from",
+              "to",
+              "workspace",
+              "memory",
+              "instructions",
+              "reingestedTokens",
+              "observedModel",
+              "modelMismatch",
+              "identityCheck",
+              "inputDelivery"
+            ],
+            "additionalProperties": false,
+            "description": "Receipt of one continued try: carrier, cause, accounts, memory, model attestation."
+          },
+          "description": "Per-try continuation receipts (carrier, cause, accounts, model) from the run's event log; omitted when not projected."
+        },
+        "retainedEnvelope": {
+          "anyOf": [
+            {
+              "type": "object",
+              "properties": {
+                "root": {
+                  "type": "string",
+                  "description": "Absolute path of the kept working tree."
+                },
+                "bytes": {
+                  "anyOf": [
+                    {
+                      "type": "integer",
+                      "minimum": 0
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "description": "Disk use of the kept envelope (tree + scoped home); null when not measured."
+                },
+                "retainedAt": {
+                  "type": "string",
+                  "description": "When the envelope was kept."
+                },
+                "cause": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/definitions/McpRunHandleResult/properties/resumable/anyOf/0/properties/cause"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ],
+                  "description": "Why the run stopped, when recorded."
+                }
+              },
+              "required": [
+                "root",
+                "bytes",
+                "retainedAt",
+                "cause"
+              ],
+              "additionalProperties": false,
+              "description": "An isolated envelope kept for continuation: continue it with continueFrom, or release it with the discard decision."
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Isolated envelope kept for a successor (disk use visible); null when none, omitted when not projected."
+        },
         "detailProblem": {
           "anyOf": [
             {