@claudexor/schema 1.0.0

package/generated/HarnessStatusDto.schema.json

@@ -0,0 +1,486 @@
+{
+  "$ref": "#/definitions/HarnessStatusDto",
+  "definitions": {
+    "HarnessStatusDto": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "Harness id."
+        },
+        "status": {
+          "type": "string",
+          "enum": [
+            "ok",
+            "degraded",
+            "unavailable"
+          ],
+          "description": "Doctor verdict for a harness: ok (usable), degraded (usable with limitations), or unavailable."
+        },
+        "manifest": {
+          "anyOf": [
+            {
+              "type": "object",
+              "properties": {
+                "id": {
+                  "type": "string",
+                  "minLength": 1,
+                  "description": "Harness id (codex, claude, cursor, opencode, raw-api, ...)."
+                },
+                "display_name": {
+                  "type": "string",
+                  "description": "Human display name of the harness."
+                },
+                "kind": {
+                  "type": "string",
+                  "enum": [
+                    "local_cli",
+                    "remote_api",
+                    "fake"
+                  ],
+                  "description": "Kind of harness adapter: a local vendor CLI, a remote API, or a fake used for tests."
+                },
+                "version": {
+                  "type": "string",
+                  "description": "Vendor CLI/API version, when discovered."
+                },
+                "adapter_version": {
+                  "type": "string",
+                  "description": "Version of the Claudexor adapter itself."
+                },
+                "provider_family": {
+                  "type": "string",
+                  "enum": [
+                    "openai",
+                    "anthropic",
+                    "google",
+                    "cursor",
+                    "opencode",
+                    "xai",
+                    "local",
+                    "unknown"
+                  ],
+                  "description": "Vendor/provider family a harness routes to, used for route-diversity reasoning; open-ended via \"unknown\".",
+                  "default": "unknown"
+                },
+                "capability_profile": {
+                  "type": "object",
+                  "properties": {
+                    "auth": {
+                      "type": "object",
+                      "properties": {
+                        "supported_sources": {
+                          "type": "array",
+                          "items": {
+                            "type": "string",
+                            "enum": [
+                              "native_session",
+                              "api_key_env",
+                              "api_key_flag",
+                              "provider_auth_file",
+                              "none"
+                            ],
+                            "description": "Where a harness's credentials can come from: a native login session, an API key via env var or CLI flag, a provider auth file, or none."
+                          },
+                          "default": [],
+                          "description": "Auth sources this harness supports."
+                        },
+                        "preferred_source": {
+                          "anyOf": [
+                            {
+                              "$ref": "#/definitions/HarnessStatusDto/properties/manifest/anyOf/0/properties/capability_profile/properties/auth/properties/supported_sources/items"
+                            },
+                            {
+                              "type": "null"
+                            }
+                          ],
+                          "description": "Auth source the adapter prefers; null when it has no preference.",
+                          "default": null
+                        },
+                        "credential_transports": {
+                          "type": "array",
+                          "items": {
+                            "type": "object",
+                            "properties": {
+                              "source": {
+                                "$ref": "#/definitions/HarnessStatusDto/properties/manifest/anyOf/0/properties/capability_profile/properties/auth/properties/supported_sources/items"
+                              },
+                              "kind": {
+                                "type": "string",
+                                "enum": [
+                                  "config_file",
+                                  "env_var",
+                                  "oauth_token_env",
+                                  "os_keychain",
+                                  "http_header",
+                                  "none"
+                                ],
+                                "description": "Mechanism that carries a credential to the harness process (config file, env var, OAuth token env, OS keychain, HTTP header, or none)."
+                              },
+                              "relocatable_by": {
+                                "type": "array",
+                                "items": {
+                                  "type": "string",
+                                  "enum": [
+                                    "HOME",
+                                    "CONFIG_DIR",
+                                    "ENV",
+                                    "none"
+                                  ],
+                                  "description": "Which relocation lever moves the credential into a scoped environment (HOME, a config dir override, env injection, or none)."
+                                },
+                                "default": [],
+                                "description": "Relocation levers that can move this transport into a scoped environment."
+                              }
+                            },
+                            "required": [
+                              "source",
+                              "kind"
+                            ],
+                            "additionalProperties": false,
+                            "description": "How a credential from one auth source physically reaches the harness process."
+                          },
+                          "default": [],
+                          "description": "Declared credential transports per auth source."
+                        }
+                      },
+                      "additionalProperties": false,
+                      "default": {},
+                      "description": "Declared auth routing facts for a harness."
+                    },
+                    "access_control": {
+                      "type": "object",
+                      "properties": {
+                        "readonly_mechanism": {
+                          "type": "string",
+                          "enum": [
+                            "fs_sandbox",
+                            "permission_deny",
+                            "tool_allowlist",
+                            "none"
+                          ],
+                          "description": "How read-only access is enforced for a harness: a filesystem sandbox, permission denial, a tool allowlist, or none (read-only intent is advisory).",
+                          "default": "none"
+                        }
+                      },
+                      "additionalProperties": false,
+                      "default": {},
+                      "description": "Declared access-control facts for a harness."
+                    },
+                    "isolation": {
+                      "type": "object",
+                      "properties": {
+                        "supported_containment": {
+                          "type": "array",
+                          "items": {
+                            "type": "string",
+                            "enum": [
+                              "env_or_file_injection",
+                              "scoped_home_keychain_bridge",
+                              "host_user_context",
+                              "process_sandbox",
+                              "container"
+                            ],
+                            "description": "Isolation containment level an adapter supports for run environments, from env/file injection through scoped-HOME keychain bridging to process sandboxes and containers."
+                          },
+                          "default": [
+                            "env_or_file_injection"
+                          ],
+                          "description": "Containment mechanisms the adapter can run under."
+                        }
+                      },
+                      "additionalProperties": false,
+                      "default": {},
+                      "description": "Declared isolation containment facts for a harness."
+                    },
+                    "image_input": {
+                      "type": "string",
+                      "enum": [
+                        "file_path",
+                        "base64_stream",
+                        "base64_inline",
+                        "none"
+                      ],
+                      "description": "How a harness accepts image input: file_path (CLI file argument), base64_stream (base64 image block on the stream), base64_inline (data-URL in the request), or none (no vision input on this route).",
+                      "default": "none"
+                    }
+                  },
+                  "additionalProperties": false,
+                  "default": {},
+                  "description": "Structured per-harness facts the engine consumes: auth routing, isolation containment, readonly mechanism, and vision input."
+                },
+                "capabilities": {
+                  "type": "object",
+                  "properties": {
+                    "plan": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "The harness can produce plans (plan intent)."
+                    },
+                    "implement": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "The harness can implement code changes (implement intent)."
+                    },
+                    "create_from_scratch": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "The harness can scaffold new projects (create_from_scratch intent)."
+                    },
+                    "review": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "The harness can act as a reviewer (review intent)."
+                    },
+                    "verify": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "The harness can act as the FinalVerifier (verify intent)."
+                    },
+                    "synthesize": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "The harness can synthesize across candidate outputs (synthesize intent)."
+                    },
+                    "read_files": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "The harness can read project files."
+                    },
+                    "browser_tool": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "The adapter can inject a browser-automation MCP server (Playwright MCP) the harness drives as browser_* tools; never injected when web policy is off."
+                    },
+                    "web_policy": {
+                      "type": "string",
+                      "enum": [
+                        "native",
+                        "tools",
+                        "uncontrolled",
+                        "none"
+                      ],
+                      "description": "How a harness can honor the external web policy: native (a native config surface), tools (permissioned tools the adapter can allow/deny), uncontrolled (can reach the web but exposes no enforceable switch), or none (no web access at all).",
+                      "default": "none"
+                    },
+                    "max_turns": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "Honors HarnessRunSpec.max_turns (e.g. a native --max-turns flag)."
+                    },
+                    "tool_lists": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "Honors tool_permission_policy allow/deny lists (e.g. a native --allowedTools flag)."
+                    },
+                    "interactive": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "The adapter can surface interactive user questions (interaction_requested events) and deliver typed answers back into the live session."
+                    },
+                    "orchestrate": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "The harness can play the autonomous orchestrate planner intent, planning multi-harness work over the typed tool belt; not a privileged role."
+                    },
+                    "json_schema_output": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "The harness can constrain its final message to a caller-supplied JSON Schema (native structured-output flag)."
+                    },
+                    "effort_levels": {
+                      "type": "array",
+                      "items": {
+                        "type": "string",
+                        "enum": [
+                          "low",
+                          "medium",
+                          "high",
+                          "xhigh",
+                          "max"
+                        ],
+                        "description": "Cross-harness reasoning-effort level, weakest to strongest; adapters declare the subset they support and a shared normalizer clamps requests onto the nearest supported level."
+                      },
+                      "default": [],
+                      "description": "Ordered (weakest to strongest) reasoning-effort levels this harness actually accepts; empty means effort is not a tunable surface."
+                    },
+                    "known_models": {
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      },
+                      "default": [],
+                      "description": "Manifest-declared model ids/aliases this harness accepts, used as the model truth source when the adapter has no live inventory; explicit models outside the truth source are refused."
+                    },
+                    "known_models_verified_against": {
+                      "type": [
+                        "string",
+                        "null"
+                      ],
+                      "default": null,
+                      "description": "Vendor CLI version the known_models hints were last verified against; null = never verified / not applicable."
+                    }
+                  },
+                  "additionalProperties": false,
+                  "description": "Declared harness capabilities the engine actually consumes for intent gating, routing, knob support, and disclosure."
+                },
+                "auth_modes": {
+                  "type": "array",
+                  "items": {
+                    "type": "string",
+                    "enum": [
+                      "local_session",
+                      "api_key",
+                      "none"
+                    ]
+                  },
+                  "default": [],
+                  "description": "Auth modes the harness supports (availability only, not readiness)."
+                },
+                "access_profiles_supported": {
+                  "type": "array",
+                  "items": {
+                    "type": "string",
+                    "enum": [
+                      "readonly",
+                      "workspace_write",
+                      "full",
+                      "external_sandbox_full",
+                      "inherit_native"
+                    ],
+                    "description": "Filesystem/command access profile for a run: readonly (no writes), workspace_write (writes inside the workspace only), full (unrestricted; requires the per-repo trust allow), external_sandbox_full (full access inside an external sandbox), inherit_native (defer to the harness's own native sandbox settings)."
+                  },
+                  "default": [],
+                  "description": "Access profiles the adapter can enforce."
+                }
+              },
+              "required": [
+                "id",
+                "display_name",
+                "kind",
+                "capabilities"
+              ],
+              "additionalProperties": false,
+              "description": "Static manifest an adapter declares for its harness: identity, kind, capabilities, auth modes, and access profiles."
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "The harness's declared manifest, when available."
+        },
+        "enabledIntents": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "default": [],
+          "description": "Intents the gateway will route to this harness."
+        },
+        "disabledIntents": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "default": [],
+          "description": "Intents the doctor disabled."
+        },
+        "checks": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "id": {
+                "type": "string",
+                "description": "Check id."
+              },
+              "status": {
+                "type": "string",
+                "enum": [
+                  "pass",
+                  "fail",
+                  "skip"
+                ],
+                "description": "Outcome of the check: pass, fail, or skip."
+              },
+              "detail": {
+                "type": "string",
+                "description": "Human-readable detail for the outcome."
+              },
+              "duration_ms": {
+                "type": "integer",
+                "minimum": 0,
+                "description": "How long the check took, in milliseconds."
+              }
+            },
+            "required": [
+              "id",
+              "status"
+            ],
+            "additionalProperties": false,
+            "description": "Result of a conformance probe for one capability check."
+          },
+          "default": [],
+          "description": "Doctor probe results."
+        },
+        "reasons": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "default": [],
+          "description": "Human-readable reasons for degraded/unavailable status."
+        },
+        "configuredModel": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "default": null,
+          "description": "The user's configured per-harness default model, if any."
+        },
+        "configuredModelCheck": {
+          "anyOf": [
+            {
+              "type": "object",
+              "properties": {
+                "status": {
+                  "type": "string",
+                  "enum": [
+                    "ok",
+                    "rejected"
+                  ],
+                  "description": "Whether the configured model passes the strict truth-source check."
+                },
+                "message": {
+                  "type": [
+                    "string",
+                    "null"
+                  ],
+                  "default": null,
+                  "description": "Actionable rejection message, when rejected."
+                }
+              },
+              "required": [
+                "status"
+              ],
+              "additionalProperties": false
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "Strict truth-source check of configuredModel; null when no model is configured."
+        }
+      },
+      "required": [
+        "id",
+        "status"
+      ],
+      "additionalProperties": false,
+      "description": "Doctor-backed status row for one harness: status, intents, checks, and configured-model validity."
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/generated/McpRunToolResult.schema.json

@@ -0,0 +1,91 @@
+{
+  "$ref": "#/definitions/McpRunToolResult",
+  "definitions": {
+    "McpRunToolResult": {
+      "type": "object",
+      "properties": {
+        "summary": {
+          "type": "string",
+          "description": "Human-readable outcome summary (same text as the tool's text content)."
+        },
+        "runId": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "description": "Daemon run id (recovery handle for inspect/follow/apply/decision); null for in-process read-only runs."
+        },
+        "runDir": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "description": "Artifact directory of the run; null when not persisted."
+        },
+        "status": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "description": "Terminal run status (success | blocked | failed | cancelled | ...)."
+        },
+        "applyEligibility": {
+          "anyOf": [
+            {
+              "type": "object",
+              "properties": {
+                "eligible": {
+                  "type": "boolean",
+                  "description": "True when the apply gate would accept this run's patch right now."
+                },
+                "state": {
+                  "type": [
+                    "string",
+                    "null"
+                  ],
+                  "description": "The gate's state classification (e.g. blocked | ungated | review_not_run | no_op | ok) when known."
+                },
+                "reason": {
+                  "type": [
+                    "string",
+                    "null"
+                  ],
+                  "description": "The gate's refusal text when not eligible (null when eligible)."
+                },
+                "requiredAction": {
+                  "type": [
+                    "string",
+                    "null"
+                  ],
+                  "description": "Honest guidance for what actually unblocks apply (typed operator decision, add gates, re-run, or nothing to apply)."
+                }
+              },
+              "required": [
+                "eligible",
+                "state",
+                "reason",
+                "requiredAction"
+              ],
+              "additionalProperties": false,
+              "description": "Derived apply-gate verdict for a run's WorkProduct (single producer in the delivery gate)."
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Apply-gate verdict for mutating runs; null for read-only routes or when no patch exists."
+        }
+      },
+      "required": [
+        "summary",
+        "runId",
+        "runDir",
+        "status",
+        "applyEligibility"
+      ],
+      "additionalProperties": false,
+      "description": "Structured MCP tool result for Claudexor run tools."
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/generated/OrchestrateContract.schema.json

@@ -0,0 +1,93 @@
+{
+  "$ref": "#/definitions/OrchestrateContract",
+  "definitions": {
+    "OrchestrateContract": {
+      "type": "object",
+      "properties": {
+        "thread_id": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Thread the orchestration belongs to."
+        },
+        "goal": {
+          "type": "string",
+          "description": "The user goal the planner is orchestrating toward."
+        },
+        "tool_belt": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "start_run",
+              "race",
+              "status",
+              "answer_question",
+              "apply",
+              "review"
+            ],
+            "description": "Tool in the orchestrate planner's belt, mapping 1:1 onto engine entry points: start_run, race (best-of-N), status, answer_question, apply, and review."
+          },
+          "default": [
+            "start_run",
+            "race",
+            "status",
+            "apply",
+            "review"
+          ],
+          "description": "Tools the planner may use this run."
+        },
+        "budget": {
+          "type": "object",
+          "properties": {
+            "max_usd": {
+              "anyOf": [
+                {
+                  "type": "number",
+                  "minimum": 0
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "default": null,
+              "description": "USD cap for the whole orchestration; null = no cap."
+            },
+            "max_tool_calls": {
+              "anyOf": [
+                {
+                  "type": "integer",
+                  "exclusiveMinimum": 0
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "default": null,
+              "description": "Maximum tool calls the executor will run; null = no cap."
+            }
+          },
+          "additionalProperties": false,
+          "default": {},
+          "description": "Budget limits for the orchestration."
+        },
+        "autonomy": {
+          "type": "string",
+          "enum": [
+            "suggest",
+            "auto_safe",
+            "auto_full"
+          ],
+          "description": "How much the orchestrate planner may act without confirmation: suggest (user executes the plan), auto_safe (auto-runs only provably safe steps), auto_full (auto-runs everything).",
+          "default": "suggest"
+        }
+      },
+      "required": [
+        "thread_id",
+        "goal"
+      ],
+      "additionalProperties": false,
+      "description": "Contract for one orchestrate run: goal, allowed tool belt, budget, and autonomy level."
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}