@hermes-hq/hodios-schema 0.1.0

package/dist/schemas.d.ts

@@ -0,0 +1,1580 @@
+/** JSON Schema (2020-12) for the YAML frontmatter of `library/<category>/<id>/<kind>.md`. */
+export declare const entrySchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://hermes-ide.com/prompts/schema/v1/entry.schema.json";
+    readonly title: "Hodios entry";
+    readonly description: "Frontmatter of a Hodios library entry (prompt, persona, workflow, rule or style). A superset of Agent Skills SKILL.md frontmatter.";
+    readonly type: "object";
+    readonly required: readonly ["schema", "id", "kind", "title", "description", "category", "version", "status"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly schema: {
+            readonly const: 1;
+            readonly description: "Entry format version. Always 1.";
+        };
+        readonly id: {
+            readonly description: "Globally unique, immutable id. Equals the entry folder name.";
+            readonly type: string;
+            readonly pattern: string;
+        };
+        readonly kind: {
+            readonly enum: readonly ["prompt", "persona", "workflow", "rule", "style"];
+            readonly description: "Entry kind. Equals the entry file name.";
+        };
+        readonly title: {
+            readonly type: "string";
+            readonly minLength: 3;
+            readonly maxLength: 80;
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 1024;
+            readonly description: "Third person; says what it does and when to use it (lint PS023: 40-200 chars).";
+        };
+        readonly category: {
+            readonly type: "string";
+            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+            readonly description: "Primary category from vocab/category.yml. Path: library/<domain>/<category>/<id>/; the domain comes from the vocab.";
+        };
+        readonly subcategory: {
+            readonly type: "string";
+            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+            readonly description: "Optional value from vocab/subcategory.yml whose parent is the category (TAXONOMY.md §2.4).";
+        };
+        readonly proposed_category: {
+            readonly type: "string";
+            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+            readonly description: "Only for category \"unsorted\": the category this entry should graduate into (TAXONOMY.md §2.5).";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly pattern: "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)$";
+            readonly description: "Entry semver.";
+        };
+        readonly status: {
+            readonly enum: readonly ["incubating", "experimental", "stable", "deprecated"];
+        };
+        readonly aliases: {
+            readonly type: "array";
+            readonly items: {
+                type: string;
+                pattern: string;
+            };
+            readonly uniqueItems: true;
+            readonly description: "Old ids that resolve to this entry. Never the entry’s own id.";
+        };
+        readonly replaced_by: {
+            readonly description: "Successor id when status is deprecated.";
+            readonly type: string;
+            readonly pattern: string;
+        };
+        readonly sunset: {
+            readonly type: "string";
+            readonly pattern: "^20\\d{2}\\.([1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\.(0|[1-9]\\d*)$";
+            readonly description: "Catalog version after which a deprecated entry may be removed.";
+        };
+        readonly stage: {
+            type: string;
+            description: string;
+            items: {
+                type: string;
+                pattern: string;
+            };
+            uniqueItems: boolean;
+        };
+        readonly stack: {
+            type: string;
+            description: string;
+            items: {
+                type: string;
+                pattern: string;
+            };
+            uniqueItems: boolean;
+        };
+        readonly requires: {
+            readonly type: "array";
+            readonly description: "Capabilities from vocab/requires.yml, or mcp:<server>.";
+            readonly items: {
+                readonly type: "string";
+                readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*(:[a-z0-9][a-z0-9._-]*)?$";
+            };
+            readonly uniqueItems: true;
+        };
+        readonly role: {
+            readonly maxItems: 4;
+            readonly type: string;
+            readonly description: string;
+            readonly items: {
+                type: string;
+                pattern: string;
+            };
+            readonly uniqueItems: boolean;
+        };
+        readonly subject: {
+            readonly maxItems: 4;
+            readonly type: string;
+            readonly description: string;
+            readonly items: {
+                type: string;
+                pattern: string;
+            };
+            readonly uniqueItems: boolean;
+        };
+        readonly advice_risk: {
+            readonly maxItems: 4;
+            readonly type: string;
+            readonly description: string;
+            readonly items: {
+                type: string;
+                pattern: string;
+            };
+            readonly uniqueItems: boolean;
+        };
+        readonly lang: {
+            readonly type: "string";
+            readonly pattern: "^[a-z]{2,3}(-[A-Z][a-z]{3})?(-([A-Z]{2}|\\d{3}))?$";
+            readonly description: "BCP 47 language of the entry text. Defaults to en.";
+        };
+        readonly inputs: {
+            type: string;
+            description: string;
+            items: {
+                type: string;
+                pattern: string;
+            };
+            uniqueItems: boolean;
+        };
+        readonly output: {
+            type: string;
+            description: string;
+            items: {
+                type: string;
+                pattern: string;
+            };
+            uniqueItems: boolean;
+        };
+        readonly tags: {
+            type: string;
+            description: string;
+            items: {
+                type: string;
+                pattern: string;
+            };
+            uniqueItems: boolean;
+        };
+        readonly risk: {
+            readonly enum: readonly ["read-only", "edits-files", "runs-commands", "network", "external"];
+        };
+        readonly invocation: {
+            readonly enum: readonly ["user", "model", "both"];
+        };
+        readonly effort: {
+            readonly enum: readonly ["quick", "standard", "deep"];
+        };
+        readonly interaction: {
+            readonly enum: readonly ["one-shot", "interactive", "autonomous"];
+        };
+        readonly model_tier: {
+            readonly enum: readonly ["small", "mid", "frontier"];
+        };
+        readonly reasoning: {
+            readonly enum: readonly ["off", "optional", "recommended"];
+        };
+        readonly level: {
+            readonly enum: readonly ["beginner", "intermediate", "expert"];
+        };
+        readonly pairs_with: {
+            readonly type: "object";
+            readonly description: "UI hint only; never a runtime dependency.";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly prompts: {
+                    readonly type: "array";
+                    readonly items: {
+                        type: string;
+                        pattern: string;
+                    };
+                    readonly uniqueItems: true;
+                };
+                readonly personas: {
+                    readonly type: "array";
+                    readonly items: {
+                        type: string;
+                        pattern: string;
+                    };
+                    readonly uniqueItems: true;
+                };
+                readonly workflows: {
+                    readonly type: "array";
+                    readonly items: {
+                        type: string;
+                        pattern: string;
+                    };
+                    readonly uniqueItems: true;
+                };
+                readonly rules: {
+                    readonly type: "array";
+                    readonly items: {
+                        type: string;
+                        pattern: string;
+                    };
+                    readonly uniqueItems: true;
+                };
+                readonly styles: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly required: readonly ["id"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly id: {
+                                type: string;
+                                pattern: string;
+                            };
+                            readonly level: {
+                                readonly type: "integer";
+                                readonly minimum: 1;
+                                readonly maximum: 5;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        readonly args: {
+            readonly type: "array";
+            readonly description: "Typed arguments, referenced in the body as {{name}}.";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["name", "description", "type"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z][a-z0-9_]*$";
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 300;
+                    };
+                    readonly type: {
+                        readonly enum: readonly ["string", "text", "enum", "number", "boolean"];
+                    };
+                    readonly required: {
+                        readonly type: "boolean";
+                    };
+                    readonly default: {
+                        readonly type: readonly ["string", "number", "boolean"];
+                    };
+                    readonly enum: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly minItems: 2;
+                        readonly uniqueItems: true;
+                    };
+                };
+                readonly if: {
+                    readonly properties: {
+                        readonly type: {
+                            readonly const: "enum";
+                        };
+                    };
+                };
+                readonly then: {
+                    readonly required: readonly ["enum"];
+                };
+                readonly else: {
+                    readonly not: {
+                        readonly required: readonly ["enum"];
+                    };
+                };
+            };
+        };
+        readonly output_contract: {
+            readonly type: "object";
+            readonly required: readonly ["format"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly format: {
+                    readonly enum: readonly ["markdown", "json", "yaml", "text", "diff"];
+                };
+                readonly sections: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly uniqueItems: true;
+                };
+                readonly strict: {
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly authorship: {
+            readonly enum: readonly ["human", "ai-assisted", "ai-generated"];
+        };
+        readonly authors: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly pattern: "^[A-Za-z0-9](-?[A-Za-z0-9]){0,38}$";
+            };
+            readonly minItems: 1;
+            readonly uniqueItems: true;
+            readonly description: "GitHub logins of the accountable humans.";
+        };
+        readonly last_reviewed: {
+            readonly type: "string";
+            readonly pattern: "^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$";
+        };
+        readonly changelog: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["version", "note"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly version: {
+                        readonly type: "string";
+                        readonly pattern: "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)$";
+                    };
+                    readonly note: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 300;
+                    };
+                };
+            };
+        };
+        readonly targets: {
+            readonly type: "object";
+            readonly description: "Per-target escape hatch. Every use prints a compiler warning.";
+            readonly propertyNames: {
+                readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+            };
+            readonly additionalProperties: {
+                readonly type: "object";
+            };
+        };
+        readonly voice: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 200;
+            readonly description: "Persona only.";
+        };
+        readonly tools: {
+            readonly type: "array";
+            readonly items: {
+                readonly enum: readonly ["read", "search", "edit", "write", "shell", "web", "git"];
+            };
+            readonly uniqueItems: true;
+            readonly description: "Persona only. Abstract tools, mapped per target.";
+        };
+        readonly color: {
+            readonly enum: readonly ["red", "orange", "yellow", "green", "cyan", "blue", "purple", "pink"];
+            readonly description: "Persona only.";
+        };
+        readonly keep_coding_instructions: {
+            readonly type: "boolean";
+            readonly description: "Persona only.";
+        };
+        readonly steps: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly description: "Workflow only. Ordered, gated steps; each file lives in steps/.";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["id", "file", "stage", "gate"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                    };
+                    readonly file: {
+                        readonly type: "string";
+                        readonly pattern: "^steps/\\d{2}-[a-z0-9]+(-[a-z0-9]+)*\\.md$";
+                    };
+                    readonly stage: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                    };
+                    readonly gate: {
+                        readonly enum: readonly ["approve", "none"];
+                    };
+                    readonly artifact: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly applies_to: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly uniqueItems: true;
+            readonly description: "Rule only. Glob patterns; omit for an always-on rule.";
+        };
+        readonly levels: {
+            readonly type: "array";
+            readonly minItems: 5;
+            readonly maxItems: 5;
+            readonly description: "Style only. Exactly 5 levels, from lightest (1) to strongest (5).";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["label", "instruction"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly label: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 40;
+                    };
+                    readonly instruction: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 600;
+                    };
+                };
+            };
+        };
+    };
+    readonly allOf: readonly [{
+        readonly if: {
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "workflow";
+                };
+            };
+        };
+        readonly then: {
+            readonly required: readonly ["steps"];
+        };
+        readonly else: {
+            readonly not: {
+                readonly required: readonly ["steps"];
+            };
+        };
+    }, {
+        readonly if: {
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "style";
+                };
+            };
+        };
+        readonly then: {
+            readonly required: readonly ["levels"];
+        };
+        readonly else: {
+            readonly not: {
+                readonly required: readonly ["levels"];
+            };
+        };
+    }, {
+        readonly if: {
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "rule";
+                };
+            };
+        };
+        readonly else: {
+            readonly not: {
+                readonly required: readonly ["applies_to"];
+            };
+        };
+    }, {
+        readonly if: {
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "persona";
+                };
+            };
+        };
+        readonly else: {
+            readonly not: {
+                readonly anyOf: readonly [{
+                    readonly required: readonly ["voice"];
+                }, {
+                    readonly required: readonly ["tools"];
+                }, {
+                    readonly required: readonly ["color"];
+                }, {
+                    readonly required: readonly ["keep_coding_instructions"];
+                }];
+            };
+        };
+    }, {
+        readonly if: {
+            readonly properties: {
+                readonly status: {
+                    readonly const: "deprecated";
+                };
+            };
+            readonly required: readonly ["status"];
+        };
+        readonly then: {
+            readonly required: readonly ["replaced_by"];
+        };
+    }, {
+        readonly if: {
+            readonly properties: {
+                readonly authorship: {
+                    readonly enum: readonly ["ai-assisted", "ai-generated"];
+                };
+            };
+            readonly required: readonly ["authorship"];
+        };
+        readonly then: {
+            readonly required: readonly ["authors"];
+        };
+    }];
+};
+export declare const ASSERTION_TYPES: readonly ["contains", "icontains", "not-contains", "not-icontains", "contains-any", "contains-all", "equals", "starts-with", "regex", "not-regex", "is-json", "javascript", "llm-rubric", "similar"];
+/** JSON Schema (2020-12) for `evals.yaml`, compiled to promptfoo by tools/evals. */
+export declare const evalsSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://hermes-ide.com/prompts/schema/v1/evals.schema.json";
+    readonly title: "Hodios entry evals";
+    readonly type: "object";
+    readonly required: readonly ["schema", "baseline", "cases"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly schema: {
+            readonly const: 1;
+        };
+        readonly baseline: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "The naive prompt the entry must beat.";
+        };
+        readonly providers: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["family", "tier"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly family: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                    };
+                    readonly tier: {
+                        readonly enum: readonly ["small", "mid", "frontier"];
+                    };
+                };
+            };
+            readonly minItems: 1;
+        };
+        readonly judge: {
+            readonly type: "object";
+            readonly required: readonly ["family", "tier"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly family: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                };
+                readonly tier: {
+                    readonly enum: readonly ["small", "mid", "frontier"];
+                };
+            };
+        };
+        readonly pass_threshold: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly maximum: 1;
+        };
+        readonly min_lift_over_baseline: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly maximum: 1;
+        };
+        readonly cases: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["name", "vars", "assert"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                    readonly vars: {
+                        readonly type: "object";
+                        readonly additionalProperties: {
+                            readonly type: readonly ["string", "number", "boolean"];
+                        };
+                    };
+                    readonly assert: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["type"];
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly type: {
+                                    readonly enum: readonly ["contains", "icontains", "not-contains", "not-icontains", "contains-any", "contains-all", "equals", "starts-with", "regex", "not-regex", "is-json", "javascript", "llm-rubric", "similar"];
+                                };
+                                readonly value: {};
+                                readonly threshold: {
+                                    readonly type: "number";
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+/** JSON Schema (2020-12) for a controlled vocabulary file in vocab/. */
+export declare const vocabSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://hermes-ide.com/prompts/schema/v1/vocab.schema.json";
+    readonly title: "Hodios controlled vocabulary";
+    readonly type: "object";
+    readonly required: readonly ["schema", "facet", "values"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly schema: {
+            readonly const: 1;
+        };
+        readonly facet: {
+            readonly type: "string";
+            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+        };
+        readonly description: {
+            readonly type: "string";
+        };
+        readonly values: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["value", "label"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly value: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                    };
+                    readonly label: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                    readonly synonyms: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        };
+                        readonly uniqueItems: true;
+                    };
+                    readonly deprecated_by: {
+                        readonly type: readonly ["string", "null"];
+                        readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                    };
+                    readonly domain: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        readonly description: "category: the owning domain.";
+                    };
+                    readonly scope_note: {
+                        readonly type: "string";
+                        readonly description: "category: the boundary with neighbouring values.";
+                    };
+                    readonly examples: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        };
+                        readonly uniqueItems: true;
+                    };
+                    readonly advice_risk: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        };
+                        readonly uniqueItems: true;
+                        readonly description: "category: advice-risk values every entry in it must declare.";
+                    };
+                    readonly layout: {
+                        readonly enum: readonly ["flat", "nested"];
+                        readonly description: "category: flat (default) or nested.";
+                    };
+                    readonly parent: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        readonly description: "subcategory: the parent category.";
+                    };
+                    readonly implies: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        };
+                        readonly uniqueItems: true;
+                        readonly description: "stack, subject: broader values this one implies.";
+                    };
+                    readonly type: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        readonly description: "stack, subject: kind of value.";
+                    };
+                    readonly detect: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly description: "stack: on-device project detection hints for Hermes.";
+                        readonly properties: {
+                            readonly files: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly uniqueItems: true;
+                            };
+                            readonly deps: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-z]+:[^\\s]+$";
+                                };
+                                readonly uniqueItems: true;
+                            };
+                        };
+                    };
+                    readonly group: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        readonly description: "role: picker group.";
+                    };
+                    readonly onet: {
+                        readonly type: "string";
+                        readonly pattern: "^\\d{2}-\\d{4}(\\.\\d{2})?$";
+                        readonly description: "role: O*NET-SOC code.";
+                    };
+                    readonly partials: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*(/[a-z0-9]+(-[a-z0-9]+)*)*$";
+                        };
+                        readonly uniqueItems: true;
+                        readonly description: "advice-risk: guardrail partials an entry with this value must include.";
+                    };
+                };
+            };
+        };
+    };
+};
+/** Every published schema, keyed by its file name under schema/. */
+export declare const schemaFiles: {
+    readonly 'entry.schema.json': {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $id: "https://hermes-ide.com/prompts/schema/v1/entry.schema.json";
+        readonly title: "Hodios entry";
+        readonly description: "Frontmatter of a Hodios library entry (prompt, persona, workflow, rule or style). A superset of Agent Skills SKILL.md frontmatter.";
+        readonly type: "object";
+        readonly required: readonly ["schema", "id", "kind", "title", "description", "category", "version", "status"];
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly schema: {
+                readonly const: 1;
+                readonly description: "Entry format version. Always 1.";
+            };
+            readonly id: {
+                readonly description: "Globally unique, immutable id. Equals the entry folder name.";
+                readonly type: string;
+                readonly pattern: string;
+            };
+            readonly kind: {
+                readonly enum: readonly ["prompt", "persona", "workflow", "rule", "style"];
+                readonly description: "Entry kind. Equals the entry file name.";
+            };
+            readonly title: {
+                readonly type: "string";
+                readonly minLength: 3;
+                readonly maxLength: 80;
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 1024;
+                readonly description: "Third person; says what it does and when to use it (lint PS023: 40-200 chars).";
+            };
+            readonly category: {
+                readonly type: "string";
+                readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                readonly description: "Primary category from vocab/category.yml. Path: library/<domain>/<category>/<id>/; the domain comes from the vocab.";
+            };
+            readonly subcategory: {
+                readonly type: "string";
+                readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                readonly description: "Optional value from vocab/subcategory.yml whose parent is the category (TAXONOMY.md §2.4).";
+            };
+            readonly proposed_category: {
+                readonly type: "string";
+                readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                readonly description: "Only for category \"unsorted\": the category this entry should graduate into (TAXONOMY.md §2.5).";
+            };
+            readonly version: {
+                readonly type: "string";
+                readonly pattern: "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)$";
+                readonly description: "Entry semver.";
+            };
+            readonly status: {
+                readonly enum: readonly ["incubating", "experimental", "stable", "deprecated"];
+            };
+            readonly aliases: {
+                readonly type: "array";
+                readonly items: {
+                    type: string;
+                    pattern: string;
+                };
+                readonly uniqueItems: true;
+                readonly description: "Old ids that resolve to this entry. Never the entry’s own id.";
+            };
+            readonly replaced_by: {
+                readonly description: "Successor id when status is deprecated.";
+                readonly type: string;
+                readonly pattern: string;
+            };
+            readonly sunset: {
+                readonly type: "string";
+                readonly pattern: "^20\\d{2}\\.([1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\.(0|[1-9]\\d*)$";
+                readonly description: "Catalog version after which a deprecated entry may be removed.";
+            };
+            readonly stage: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    pattern: string;
+                };
+                uniqueItems: boolean;
+            };
+            readonly stack: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    pattern: string;
+                };
+                uniqueItems: boolean;
+            };
+            readonly requires: {
+                readonly type: "array";
+                readonly description: "Capabilities from vocab/requires.yml, or mcp:<server>.";
+                readonly items: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*(:[a-z0-9][a-z0-9._-]*)?$";
+                };
+                readonly uniqueItems: true;
+            };
+            readonly role: {
+                readonly maxItems: 4;
+                readonly type: string;
+                readonly description: string;
+                readonly items: {
+                    type: string;
+                    pattern: string;
+                };
+                readonly uniqueItems: boolean;
+            };
+            readonly subject: {
+                readonly maxItems: 4;
+                readonly type: string;
+                readonly description: string;
+                readonly items: {
+                    type: string;
+                    pattern: string;
+                };
+                readonly uniqueItems: boolean;
+            };
+            readonly advice_risk: {
+                readonly maxItems: 4;
+                readonly type: string;
+                readonly description: string;
+                readonly items: {
+                    type: string;
+                    pattern: string;
+                };
+                readonly uniqueItems: boolean;
+            };
+            readonly lang: {
+                readonly type: "string";
+                readonly pattern: "^[a-z]{2,3}(-[A-Z][a-z]{3})?(-([A-Z]{2}|\\d{3}))?$";
+                readonly description: "BCP 47 language of the entry text. Defaults to en.";
+            };
+            readonly inputs: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    pattern: string;
+                };
+                uniqueItems: boolean;
+            };
+            readonly output: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    pattern: string;
+                };
+                uniqueItems: boolean;
+            };
+            readonly tags: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    pattern: string;
+                };
+                uniqueItems: boolean;
+            };
+            readonly risk: {
+                readonly enum: readonly ["read-only", "edits-files", "runs-commands", "network", "external"];
+            };
+            readonly invocation: {
+                readonly enum: readonly ["user", "model", "both"];
+            };
+            readonly effort: {
+                readonly enum: readonly ["quick", "standard", "deep"];
+            };
+            readonly interaction: {
+                readonly enum: readonly ["one-shot", "interactive", "autonomous"];
+            };
+            readonly model_tier: {
+                readonly enum: readonly ["small", "mid", "frontier"];
+            };
+            readonly reasoning: {
+                readonly enum: readonly ["off", "optional", "recommended"];
+            };
+            readonly level: {
+                readonly enum: readonly ["beginner", "intermediate", "expert"];
+            };
+            readonly pairs_with: {
+                readonly type: "object";
+                readonly description: "UI hint only; never a runtime dependency.";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly prompts: {
+                        readonly type: "array";
+                        readonly items: {
+                            type: string;
+                            pattern: string;
+                        };
+                        readonly uniqueItems: true;
+                    };
+                    readonly personas: {
+                        readonly type: "array";
+                        readonly items: {
+                            type: string;
+                            pattern: string;
+                        };
+                        readonly uniqueItems: true;
+                    };
+                    readonly workflows: {
+                        readonly type: "array";
+                        readonly items: {
+                            type: string;
+                            pattern: string;
+                        };
+                        readonly uniqueItems: true;
+                    };
+                    readonly rules: {
+                        readonly type: "array";
+                        readonly items: {
+                            type: string;
+                            pattern: string;
+                        };
+                        readonly uniqueItems: true;
+                    };
+                    readonly styles: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["id"];
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly id: {
+                                    type: string;
+                                    pattern: string;
+                                };
+                                readonly level: {
+                                    readonly type: "integer";
+                                    readonly minimum: 1;
+                                    readonly maximum: 5;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            readonly args: {
+                readonly type: "array";
+                readonly description: "Typed arguments, referenced in the body as {{name}}.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["name", "description", "type"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly name: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z][a-z0-9_]*$";
+                        };
+                        readonly description: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly maxLength: 300;
+                        };
+                        readonly type: {
+                            readonly enum: readonly ["string", "text", "enum", "number", "boolean"];
+                        };
+                        readonly required: {
+                            readonly type: "boolean";
+                        };
+                        readonly default: {
+                            readonly type: readonly ["string", "number", "boolean"];
+                        };
+                        readonly enum: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly minItems: 2;
+                            readonly uniqueItems: true;
+                        };
+                    };
+                    readonly if: {
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "enum";
+                            };
+                        };
+                    };
+                    readonly then: {
+                        readonly required: readonly ["enum"];
+                    };
+                    readonly else: {
+                        readonly not: {
+                            readonly required: readonly ["enum"];
+                        };
+                    };
+                };
+            };
+            readonly output_contract: {
+                readonly type: "object";
+                readonly required: readonly ["format"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly format: {
+                        readonly enum: readonly ["markdown", "json", "yaml", "text", "diff"];
+                    };
+                    readonly sections: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly uniqueItems: true;
+                    };
+                    readonly strict: {
+                        readonly type: "boolean";
+                    };
+                };
+            };
+            readonly authorship: {
+                readonly enum: readonly ["human", "ai-assisted", "ai-generated"];
+            };
+            readonly authors: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly pattern: "^[A-Za-z0-9](-?[A-Za-z0-9]){0,38}$";
+                };
+                readonly minItems: 1;
+                readonly uniqueItems: true;
+                readonly description: "GitHub logins of the accountable humans.";
+            };
+            readonly last_reviewed: {
+                readonly type: "string";
+                readonly pattern: "^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$";
+            };
+            readonly changelog: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["version", "note"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly version: {
+                            readonly type: "string";
+                            readonly pattern: "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)$";
+                        };
+                        readonly note: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly maxLength: 300;
+                        };
+                    };
+                };
+            };
+            readonly targets: {
+                readonly type: "object";
+                readonly description: "Per-target escape hatch. Every use prints a compiler warning.";
+                readonly propertyNames: {
+                    readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                };
+                readonly additionalProperties: {
+                    readonly type: "object";
+                };
+            };
+            readonly voice: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 200;
+                readonly description: "Persona only.";
+            };
+            readonly tools: {
+                readonly type: "array";
+                readonly items: {
+                    readonly enum: readonly ["read", "search", "edit", "write", "shell", "web", "git"];
+                };
+                readonly uniqueItems: true;
+                readonly description: "Persona only. Abstract tools, mapped per target.";
+            };
+            readonly color: {
+                readonly enum: readonly ["red", "orange", "yellow", "green", "cyan", "blue", "purple", "pink"];
+                readonly description: "Persona only.";
+            };
+            readonly keep_coding_instructions: {
+                readonly type: "boolean";
+                readonly description: "Persona only.";
+            };
+            readonly steps: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly description: "Workflow only. Ordered, gated steps; each file lives in steps/.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["id", "file", "stage", "gate"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        };
+                        readonly file: {
+                            readonly type: "string";
+                            readonly pattern: "^steps/\\d{2}-[a-z0-9]+(-[a-z0-9]+)*\\.md$";
+                        };
+                        readonly stage: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        };
+                        readonly gate: {
+                            readonly enum: readonly ["approve", "none"];
+                        };
+                        readonly artifact: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+            };
+            readonly applies_to: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly uniqueItems: true;
+                readonly description: "Rule only. Glob patterns; omit for an always-on rule.";
+            };
+            readonly levels: {
+                readonly type: "array";
+                readonly minItems: 5;
+                readonly maxItems: 5;
+                readonly description: "Style only. Exactly 5 levels, from lightest (1) to strongest (5).";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["label", "instruction"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly label: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly maxLength: 40;
+                        };
+                        readonly instruction: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly maxLength: 600;
+                        };
+                    };
+                };
+            };
+        };
+        readonly allOf: readonly [{
+            readonly if: {
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "workflow";
+                    };
+                };
+            };
+            readonly then: {
+                readonly required: readonly ["steps"];
+            };
+            readonly else: {
+                readonly not: {
+                    readonly required: readonly ["steps"];
+                };
+            };
+        }, {
+            readonly if: {
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "style";
+                    };
+                };
+            };
+            readonly then: {
+                readonly required: readonly ["levels"];
+            };
+            readonly else: {
+                readonly not: {
+                    readonly required: readonly ["levels"];
+                };
+            };
+        }, {
+            readonly if: {
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "rule";
+                    };
+                };
+            };
+            readonly else: {
+                readonly not: {
+                    readonly required: readonly ["applies_to"];
+                };
+            };
+        }, {
+            readonly if: {
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "persona";
+                    };
+                };
+            };
+            readonly else: {
+                readonly not: {
+                    readonly anyOf: readonly [{
+                        readonly required: readonly ["voice"];
+                    }, {
+                        readonly required: readonly ["tools"];
+                    }, {
+                        readonly required: readonly ["color"];
+                    }, {
+                        readonly required: readonly ["keep_coding_instructions"];
+                    }];
+                };
+            };
+        }, {
+            readonly if: {
+                readonly properties: {
+                    readonly status: {
+                        readonly const: "deprecated";
+                    };
+                };
+                readonly required: readonly ["status"];
+            };
+            readonly then: {
+                readonly required: readonly ["replaced_by"];
+            };
+        }, {
+            readonly if: {
+                readonly properties: {
+                    readonly authorship: {
+                        readonly enum: readonly ["ai-assisted", "ai-generated"];
+                    };
+                };
+                readonly required: readonly ["authorship"];
+            };
+            readonly then: {
+                readonly required: readonly ["authors"];
+            };
+        }];
+    };
+    readonly 'evals.schema.json': {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $id: "https://hermes-ide.com/prompts/schema/v1/evals.schema.json";
+        readonly title: "Hodios entry evals";
+        readonly type: "object";
+        readonly required: readonly ["schema", "baseline", "cases"];
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly schema: {
+                readonly const: 1;
+            };
+            readonly baseline: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly description: "The naive prompt the entry must beat.";
+            };
+            readonly providers: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["family", "tier"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly family: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        };
+                        readonly tier: {
+                            readonly enum: readonly ["small", "mid", "frontier"];
+                        };
+                    };
+                };
+                readonly minItems: 1;
+            };
+            readonly judge: {
+                readonly type: "object";
+                readonly required: readonly ["family", "tier"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly family: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                    };
+                    readonly tier: {
+                        readonly enum: readonly ["small", "mid", "frontier"];
+                    };
+                };
+            };
+            readonly pass_threshold: {
+                readonly type: "number";
+                readonly minimum: 0;
+                readonly maximum: 1;
+            };
+            readonly min_lift_over_baseline: {
+                readonly type: "number";
+                readonly minimum: 0;
+                readonly maximum: 1;
+            };
+            readonly cases: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["name", "vars", "assert"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly name: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        };
+                        readonly description: {
+                            readonly type: "string";
+                        };
+                        readonly vars: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: readonly ["string", "number", "boolean"];
+                            };
+                        };
+                        readonly assert: {
+                            readonly type: "array";
+                            readonly minItems: 1;
+                            readonly items: {
+                                readonly type: "object";
+                                readonly required: readonly ["type"];
+                                readonly additionalProperties: false;
+                                readonly properties: {
+                                    readonly type: {
+                                        readonly enum: readonly ["contains", "icontains", "not-contains", "not-icontains", "contains-any", "contains-all", "equals", "starts-with", "regex", "not-regex", "is-json", "javascript", "llm-rubric", "similar"];
+                                    };
+                                    readonly value: {};
+                                    readonly threshold: {
+                                        readonly type: "number";
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly 'vocab.schema.json': {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $id: "https://hermes-ide.com/prompts/schema/v1/vocab.schema.json";
+        readonly title: "Hodios controlled vocabulary";
+        readonly type: "object";
+        readonly required: readonly ["schema", "facet", "values"];
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly schema: {
+                readonly const: 1;
+            };
+            readonly facet: {
+                readonly type: "string";
+                readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+            };
+            readonly description: {
+                readonly type: "string";
+            };
+            readonly values: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["value", "label"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly value: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        };
+                        readonly label: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly description: {
+                            readonly type: "string";
+                        };
+                        readonly synonyms: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly deprecated_by: {
+                            readonly type: readonly ["string", "null"];
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                        };
+                        readonly domain: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                            readonly description: "category: the owning domain.";
+                        };
+                        readonly scope_note: {
+                            readonly type: "string";
+                            readonly description: "category: the boundary with neighbouring values.";
+                        };
+                        readonly examples: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly advice_risk: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                            };
+                            readonly uniqueItems: true;
+                            readonly description: "category: advice-risk values every entry in it must declare.";
+                        };
+                        readonly layout: {
+                            readonly enum: readonly ["flat", "nested"];
+                            readonly description: "category: flat (default) or nested.";
+                        };
+                        readonly parent: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                            readonly description: "subcategory: the parent category.";
+                        };
+                        readonly implies: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                            };
+                            readonly uniqueItems: true;
+                            readonly description: "stack, subject: broader values this one implies.";
+                        };
+                        readonly type: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                            readonly description: "stack, subject: kind of value.";
+                        };
+                        readonly detect: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly description: "stack: on-device project detection hints for Hermes.";
+                            readonly properties: {
+                                readonly files: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                                readonly deps: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly pattern: "^[a-z]+:[^\\s]+$";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                            };
+                        };
+                        readonly group: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*$";
+                            readonly description: "role: picker group.";
+                        };
+                        readonly onet: {
+                            readonly type: "string";
+                            readonly pattern: "^\\d{2}-\\d{4}(\\.\\d{2})?$";
+                            readonly description: "role: O*NET-SOC code.";
+                        };
+                        readonly partials: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-z0-9]+(-[a-z0-9]+)*(/[a-z0-9]+(-[a-z0-9]+)*)*$";
+                            };
+                            readonly uniqueItems: true;
+                            readonly description: "advice-risk: guardrail partials an entry with this value must include.";
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=schemas.d.ts.map