@eir-labs/coltrane 0.4.0

package/dist/src/genome_schema.d.ts

@@ -0,0 +1,512 @@
+import { z } from "zod";
+export declare const PrimitiveSchema: z.ZodEnum<["SENSE", "INTERPRET", "JUDGE", "PLAN", "CREATE", "VERIFY"]>;
+export declare const BelbinRoleSchema: z.ZodEnum<["explorer", "analyst", "critic", "synthesizer", "planner", "executor", "audience_modeler"]>;
+export declare const CodeToolAccessSchema: z.ZodEnum<["none", "read", "write", "full"]>;
+export declare const ModelTierSchema: z.ZodEnum<["economy", "standard", "premium"]>;
+export declare const DepthSchema: z.ZodEnum<["skim", "quick", "standard", "deep"]>;
+export declare const BrowserGrantSchema: z.ZodObject<{
+    allowed_origins: z.ZodArray<z.ZodString, "many">;
+    blocked_origins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    trace_dir: z.ZodOptional<z.ZodString>;
+    isolated: z.ZodOptional<z.ZodBoolean>;
+    headless: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    allowed_origins: string[];
+    blocked_origins?: string[] | undefined;
+    trace_dir?: string | undefined;
+    isolated?: boolean | undefined;
+    headless?: boolean | undefined;
+}, {
+    allowed_origins: string[];
+    blocked_origins?: string[] | undefined;
+    trace_dir?: string | undefined;
+    isolated?: boolean | undefined;
+    headless?: boolean | undefined;
+}>;
+export type BrowserGrant = z.output<typeof BrowserGrantSchema>;
+export declare const AgentSchema: z.ZodObject<{
+    slug: z.ZodString;
+    primitives: z.ZodReadonly<z.ZodArray<z.ZodEnum<["SENSE", "INTERPRET", "JUDGE", "PLAN", "CREATE", "VERIFY"]>, "many">>;
+    input_types: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
+    output_types: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
+    domain: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    identity: z.ZodString;
+    method: z.ZodString;
+    constraints: z.ZodReadonly<z.ZodArray<z.ZodString, "many">>;
+    behavioral_primitives: z.ZodReadonly<z.ZodTuple<[z.ZodEnum<["explorer", "analyst", "critic", "synthesizer", "planner", "executor", "audience_modeler"]>, z.ZodEnum<["explorer", "analyst", "critic", "synthesizer", "planner", "executor", "audience_modeler"]>], null>>;
+    allowed_tools: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
+    disallowed_tools: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
+    skill_slugs: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
+    model_tier: z.ZodOptional<z.ZodEnum<["economy", "standard", "premium"]>>;
+    max_tool_calls: z.ZodOptional<z.ZodNumber>;
+    max_token_budget: z.ZodOptional<z.ZodNumber>;
+    code_tool_access: z.ZodOptional<z.ZodEnum<["none", "read", "write", "full"]>>;
+    depth_profile: z.ZodOptional<z.ZodEnum<["skim", "quick", "standard", "deep"]>>;
+    browser_grant: z.ZodOptional<z.ZodObject<{
+        allowed_origins: z.ZodArray<z.ZodString, "many">;
+        blocked_origins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        trace_dir: z.ZodOptional<z.ZodString>;
+        isolated: z.ZodOptional<z.ZodBoolean>;
+        headless: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        allowed_origins: string[];
+        blocked_origins?: string[] | undefined;
+        trace_dir?: string | undefined;
+        isolated?: boolean | undefined;
+        headless?: boolean | undefined;
+    }, {
+        allowed_origins: string[];
+        blocked_origins?: string[] | undefined;
+        trace_dir?: string | undefined;
+        isolated?: boolean | undefined;
+        headless?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    primitives: readonly ("SENSE" | "INTERPRET" | "JUDGE" | "PLAN" | "CREATE" | "VERIFY")[];
+    input_types: readonly string[];
+    output_types: readonly string[];
+    domain: string | null;
+    identity: string;
+    method: string;
+    constraints: readonly string[];
+    behavioral_primitives: readonly ["explorer" | "analyst" | "critic" | "synthesizer" | "planner" | "executor" | "audience_modeler", "explorer" | "analyst" | "critic" | "synthesizer" | "planner" | "executor" | "audience_modeler"];
+    depth_profile?: "skim" | "quick" | "standard" | "deep" | undefined;
+    allowed_tools?: readonly string[] | undefined;
+    disallowed_tools?: readonly string[] | undefined;
+    skill_slugs?: readonly string[] | undefined;
+    model_tier?: "standard" | "economy" | "premium" | undefined;
+    max_tool_calls?: number | undefined;
+    max_token_budget?: number | undefined;
+    code_tool_access?: "none" | "read" | "write" | "full" | undefined;
+    browser_grant?: {
+        allowed_origins: string[];
+        blocked_origins?: string[] | undefined;
+        trace_dir?: string | undefined;
+        isolated?: boolean | undefined;
+        headless?: boolean | undefined;
+    } | undefined;
+}, {
+    slug: string;
+    primitives: readonly ("SENSE" | "INTERPRET" | "JUDGE" | "PLAN" | "CREATE" | "VERIFY")[];
+    identity: string;
+    method: string;
+    constraints: readonly string[];
+    behavioral_primitives: readonly ["explorer" | "analyst" | "critic" | "synthesizer" | "planner" | "executor" | "audience_modeler", "explorer" | "analyst" | "critic" | "synthesizer" | "planner" | "executor" | "audience_modeler"];
+    input_types?: readonly string[] | undefined;
+    output_types?: readonly string[] | undefined;
+    domain?: string | null | undefined;
+    depth_profile?: "skim" | "quick" | "standard" | "deep" | undefined;
+    allowed_tools?: readonly string[] | undefined;
+    disallowed_tools?: readonly string[] | undefined;
+    skill_slugs?: readonly string[] | undefined;
+    model_tier?: "standard" | "economy" | "premium" | undefined;
+    max_tool_calls?: number | undefined;
+    max_token_budget?: number | undefined;
+    code_tool_access?: "none" | "read" | "write" | "full" | undefined;
+    browser_grant?: {
+        allowed_origins: string[];
+        blocked_origins?: string[] | undefined;
+        trace_dir?: string | undefined;
+        isolated?: boolean | undefined;
+        headless?: boolean | undefined;
+    } | undefined;
+}>;
+export type AgentInput = z.input<typeof AgentSchema>;
+export type AgentOutput = z.output<typeof AgentSchema>;
+export declare const ChairSchema: z.ZodObject<{
+    role: z.ZodString;
+    agent_slug: z.ZodOptional<z.ZodString>;
+    skill_slug: z.ZodOptional<z.ZodString>;
+    depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    input_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    output_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    optional_outputs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    required_skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+    depends_on: string[];
+    input_contract: string[];
+    output_contract: string[];
+    optional_outputs: string[];
+    required_skills: string[];
+    agent_slug?: string | undefined;
+    skill_slug?: string | undefined;
+}, {
+    role: string;
+    agent_slug?: string | undefined;
+    skill_slug?: string | undefined;
+    depends_on?: string[] | undefined;
+    input_contract?: string[] | undefined;
+    output_contract?: string[] | undefined;
+    optional_outputs?: string[] | undefined;
+    required_skills?: string[] | undefined;
+}>;
+export declare const PhaseSchema: z.ZodObject<{
+    name: z.ZodString;
+    chairs: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        agent_slug: z.ZodOptional<z.ZodString>;
+        skill_slug: z.ZodOptional<z.ZodString>;
+        depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        input_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        output_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        optional_outputs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        required_skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        role: string;
+        depends_on: string[];
+        input_contract: string[];
+        output_contract: string[];
+        optional_outputs: string[];
+        required_skills: string[];
+        agent_slug?: string | undefined;
+        skill_slug?: string | undefined;
+    }, {
+        role: string;
+        agent_slug?: string | undefined;
+        skill_slug?: string | undefined;
+        depends_on?: string[] | undefined;
+        input_contract?: string[] | undefined;
+        output_contract?: string[] | undefined;
+        optional_outputs?: string[] | undefined;
+        required_skills?: string[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    chairs: {
+        role: string;
+        depends_on: string[];
+        input_contract: string[];
+        output_contract: string[];
+        optional_outputs: string[];
+        required_skills: string[];
+        agent_slug?: string | undefined;
+        skill_slug?: string | undefined;
+    }[];
+}, {
+    name: string;
+    chairs: {
+        role: string;
+        agent_slug?: string | undefined;
+        skill_slug?: string | undefined;
+        depends_on?: string[] | undefined;
+        input_contract?: string[] | undefined;
+        output_contract?: string[] | undefined;
+        optional_outputs?: string[] | undefined;
+        required_skills?: string[] | undefined;
+    }[];
+}>;
+export declare const StandardSchema: z.ZodObject<{
+    slug: z.ZodString;
+    domain: z.ZodString;
+    agents: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    agent_slugs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    phases: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        chairs: z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            agent_slug: z.ZodOptional<z.ZodString>;
+            skill_slug: z.ZodOptional<z.ZodString>;
+            depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            input_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            output_contract: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            optional_outputs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            required_skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            role: string;
+            depends_on: string[];
+            input_contract: string[];
+            output_contract: string[];
+            optional_outputs: string[];
+            required_skills: string[];
+            agent_slug?: string | undefined;
+            skill_slug?: string | undefined;
+        }, {
+            role: string;
+            agent_slug?: string | undefined;
+            skill_slug?: string | undefined;
+            depends_on?: string[] | undefined;
+            input_contract?: string[] | undefined;
+            output_contract?: string[] | undefined;
+            optional_outputs?: string[] | undefined;
+            required_skills?: string[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        chairs: {
+            role: string;
+            depends_on: string[];
+            input_contract: string[];
+            output_contract: string[];
+            optional_outputs: string[];
+            required_skills: string[];
+            agent_slug?: string | undefined;
+            skill_slug?: string | undefined;
+        }[];
+    }, {
+        name: string;
+        chairs: {
+            role: string;
+            agent_slug?: string | undefined;
+            skill_slug?: string | undefined;
+            depends_on?: string[] | undefined;
+            input_contract?: string[] | undefined;
+            output_contract?: string[] | undefined;
+            optional_outputs?: string[] | undefined;
+            required_skills?: string[] | undefined;
+        }[];
+    }>, "many">;
+    eval_slugs: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
+    input_types: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
+    output_types: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString, "many">>>;
+    max_examine_rounds: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    domain: string;
+    phases: {
+        name: string;
+        chairs: {
+            role: string;
+            depends_on: string[];
+            input_contract: string[];
+            output_contract: string[];
+            optional_outputs: string[];
+            required_skills: string[];
+            agent_slug?: string | undefined;
+            skill_slug?: string | undefined;
+        }[];
+    }[];
+    input_types?: readonly string[] | undefined;
+    output_types?: readonly string[] | undefined;
+    agents?: unknown[] | undefined;
+    agent_slugs?: string[] | undefined;
+    eval_slugs?: readonly string[] | undefined;
+    max_examine_rounds?: number | undefined;
+    description?: string | undefined;
+}, {
+    slug: string;
+    domain: string;
+    phases: {
+        name: string;
+        chairs: {
+            role: string;
+            agent_slug?: string | undefined;
+            skill_slug?: string | undefined;
+            depends_on?: string[] | undefined;
+            input_contract?: string[] | undefined;
+            output_contract?: string[] | undefined;
+            optional_outputs?: string[] | undefined;
+            required_skills?: string[] | undefined;
+        }[];
+    }[];
+    input_types?: readonly string[] | undefined;
+    output_types?: readonly string[] | undefined;
+    agents?: unknown[] | undefined;
+    agent_slugs?: string[] | undefined;
+    eval_slugs?: readonly string[] | undefined;
+    max_examine_rounds?: number | undefined;
+    description?: string | undefined;
+}>;
+export type StandardInput = z.input<typeof StandardSchema>;
+export type StandardOutput = z.output<typeof StandardSchema>;
+export declare const NetworkGrantSchema: z.ZodObject<{
+    allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    max_requests: z.ZodOptional<z.ZodNumber>;
+    max_bytes: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    allow: string[];
+    methods?: string[] | undefined;
+    max_requests?: number | undefined;
+    max_bytes?: number | undefined;
+}, {
+    allow?: string[] | undefined;
+    methods?: string[] | undefined;
+    max_requests?: number | undefined;
+    max_bytes?: number | undefined;
+}>;
+export declare const SkillPermissionSchema: z.ZodObject<{
+    tier: z.ZodOptional<z.ZodNumber>;
+    network: z.ZodOptional<z.ZodObject<{
+        allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        max_requests: z.ZodOptional<z.ZodNumber>;
+        max_bytes: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        allow: string[];
+        methods?: string[] | undefined;
+        max_requests?: number | undefined;
+        max_bytes?: number | undefined;
+    }, {
+        allow?: string[] | undefined;
+        methods?: string[] | undefined;
+        max_requests?: number | undefined;
+        max_bytes?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    tier?: number | undefined;
+    network?: {
+        allow: string[];
+        methods?: string[] | undefined;
+        max_requests?: number | undefined;
+        max_bytes?: number | undefined;
+    } | undefined;
+}, {
+    tier?: number | undefined;
+    network?: {
+        allow?: string[] | undefined;
+        methods?: string[] | undefined;
+        max_requests?: number | undefined;
+        max_bytes?: number | undefined;
+    } | undefined;
+}>;
+export declare const SkillSchema: z.ZodObject<{
+    slug: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
+    skill_type: z.ZodOptional<z.ZodString>;
+    input_type: z.ZodOptional<z.ZodString>;
+    output_type: z.ZodOptional<z.ZodString>;
+    corpus: z.ZodOptional<z.ZodString>;
+    determinism_ratio: z.ZodOptional<z.ZodNumber>;
+    permission: z.ZodOptional<z.ZodObject<{
+        tier: z.ZodOptional<z.ZodNumber>;
+        network: z.ZodOptional<z.ZodObject<{
+            allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            max_requests: z.ZodOptional<z.ZodNumber>;
+            max_bytes: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            allow: string[];
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        }, {
+            allow?: string[] | undefined;
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        tier?: number | undefined;
+        network?: {
+            allow: string[];
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        } | undefined;
+    }, {
+        tier?: number | undefined;
+        network?: {
+            allow?: string[] | undefined;
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        } | undefined;
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    fixtures: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    code: z.ZodOptional<z.ZodString>;
+    md: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    version?: number | undefined;
+    code?: string | undefined;
+    description?: string | undefined;
+    skill_type?: string | undefined;
+    input_type?: string | undefined;
+    output_type?: string | undefined;
+    corpus?: string | undefined;
+    determinism_ratio?: number | undefined;
+    permission?: {
+        tier?: number | undefined;
+        network?: {
+            allow: string[];
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        } | undefined;
+    } | undefined;
+    timeout_ms?: number | undefined;
+    fixtures?: unknown[] | undefined;
+    md?: string | undefined;
+}, {
+    slug: string;
+    version?: number | undefined;
+    code?: string | undefined;
+    description?: string | undefined;
+    skill_type?: string | undefined;
+    input_type?: string | undefined;
+    output_type?: string | undefined;
+    corpus?: string | undefined;
+    determinism_ratio?: number | undefined;
+    permission?: {
+        tier?: number | undefined;
+        network?: {
+            allow?: string[] | undefined;
+            methods?: string[] | undefined;
+            max_requests?: number | undefined;
+            max_bytes?: number | undefined;
+        } | undefined;
+    } | undefined;
+    timeout_ms?: number | undefined;
+    fixtures?: unknown[] | undefined;
+    md?: string | undefined;
+}>;
+export declare const EvalSchema: z.ZodObject<{
+    slug: z.ZodString;
+    domain: z.ZodOptional<z.ZodString>;
+    on_type: z.ZodOptional<z.ZodString>;
+    non_empty_fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    asserts: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    domain?: string | undefined;
+    on_type?: string | undefined;
+    non_empty_fields?: string[] | undefined;
+    asserts?: string | undefined;
+}, {
+    slug: string;
+    domain?: string | undefined;
+    on_type?: string | undefined;
+    non_empty_fields?: string[] | undefined;
+    asserts?: string | undefined;
+}>;
+export declare const DomainTypeStatusSchema: z.ZodEnum<["active", "deprecated", "retired"]>;
+export declare const DomainTypeSchema: z.ZodObject<{
+    slug: z.ZodString;
+    version: z.ZodDefault<z.ZodNumber>;
+    extends: z.ZodString;
+    domain: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<["active", "deprecated", "retired"]>>;
+    description: z.ZodOptional<z.ZodString>;
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    required_fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    version: number;
+    status: "active" | "retired" | "deprecated";
+    domain: string;
+    extends: string;
+    schema: Record<string, unknown>;
+    required_fields: string[];
+    description?: string | undefined;
+}, {
+    slug: string;
+    domain: string;
+    extends: string;
+    schema: Record<string, unknown>;
+    version?: number | undefined;
+    status?: "active" | "retired" | "deprecated" | undefined;
+    description?: string | undefined;
+    required_fields?: string[] | undefined;
+}>;
+export type SkillOutput = z.output<typeof SkillSchema>;
+export type EvalOutput = z.output<typeof EvalSchema>;
+export type DomainTypeOutput = z.output<typeof DomainTypeSchema>;
+type JsonType = "string" | "number" | "boolean" | "array" | "object";
+/** The MCP `properties` map (field → JSON type) for a genome class schema. */
+export declare function zodToMcpProps(schema: z.ZodObject<z.ZodRawShape>): Record<string, JsonType>;
+export {};

package/dist/src/genome_schema.js

@@ -0,0 +1,168 @@
+// genome_schema.ts — the genome's DNA, defined ONCE in Zod. Every genome class's shape lived in
+// 3-5 hand-maintained places (the TS type, the construction function, the MCP input_schema, the
+// handler, the file format) and they drifted — a field added to the type silently never reached the
+// MCP surface; a constructor quietly dropped a sealed field; the loader validated skills/evals as
+// untyped bags. This module is the single source: from each schema we derive the TYPE (z.infer),
+// the VALIDATOR (.parse), the MCP input_schema (zodToMcpProps), and the loader's file validation.
+// Add a field once here and every restatement follows.
+import { z } from "zod";
+// ── Building blocks (the shared sub-schemas the classes compose from) ─────────────
+export const PrimitiveSchema = z.enum(["SENSE", "INTERPRET", "JUDGE", "PLAN", "CREATE", "VERIFY"]);
+export const BelbinRoleSchema = z.enum(["explorer", "analyst", "critic", "synthesizer", "planner", "executor", "audience_modeler"]);
+export const CodeToolAccessSchema = z.enum(["none", "read", "write", "full"]);
+export const ModelTierSchema = z.enum(["economy", "standard", "premium"]);
+export const DepthSchema = z.enum(["skim", "quick", "standard", "deep"]);
+// The caged-browser grant (the cage branch adds browser_grant to the agent; the schema is here so
+// the grant is validated like any field). Network grant for skills lives in the skill schema.
+export const BrowserGrantSchema = z.object({
+    allowed_origins: z.array(z.string()),
+    blocked_origins: z.array(z.string()).optional(),
+    trace_dir: z.string().optional(),
+    isolated: z.boolean().optional(),
+    headless: z.boolean().optional(),
+});
+// ── Agent — the template class, migrated end-to-end. z.input = AgentDef (what you author,
+//    optionals allowed); z.output = Agent (defaults applied). One definition, both types. ──
+export const AgentSchema = z.object({
+    slug: z.string(),
+    primitives: z.array(PrimitiveSchema).readonly(),
+    input_types: z.array(z.string()).readonly().default([]),
+    output_types: z.array(z.string()).readonly().default([]),
+    domain: z.string().nullable().default(null),
+    identity: z.string(),
+    method: z.string(),
+    constraints: z.array(z.string()).readonly(),
+    behavioral_primitives: z.tuple([BelbinRoleSchema, BelbinRoleSchema]).readonly(),
+    // optional on the OUTPUT type too (defineAgent fills []) — matches the current Agent interface so
+    // the ~50 call-sites that build Agent objects don't all break. defineAgent applies the [] default.
+    allowed_tools: z.array(z.string()).readonly().optional(),
+    disallowed_tools: z.array(z.string()).readonly().optional(),
+    skill_slugs: z.array(z.string()).readonly().optional(),
+    model_tier: ModelTierSchema.optional(),
+    max_tool_calls: z.number().optional(),
+    max_token_budget: z.number().optional(),
+    code_tool_access: CodeToolAccessSchema.optional(),
+    depth_profile: DepthSchema.optional(),
+    browser_grant: BrowserGrantSchema.optional(),
+});
+// ── Chair / Phase / Standard — the schema is the DNA; the runtime Standard (resolved agents) is a
+//    transform output and stays a derived type in composition.ts. The FILE/compose shape is here. ──
+export const ChairSchema = z.object({
+    role: z.string(),
+    agent_slug: z.string().optional(),
+    skill_slug: z.string().optional(),
+    depends_on: z.array(z.string()).default([]),
+    input_contract: z.array(z.string()).default([]),
+    output_contract: z.array(z.string()).default([]),
+    // #243 — which promised outputs may legitimately be absent. Deny-by-default: omitted
+    // means every promised type is required. Subset of output_contract, checked at compose.
+    optional_outputs: z.array(z.string()).default([]),
+    required_skills: z.array(z.string()).default([]),
+});
+export const PhaseSchema = z.object({ name: z.string(), chairs: z.array(ChairSchema) });
+export const StandardSchema = z.object({
+    slug: z.string(),
+    domain: z.string(),
+    agents: z.array(z.unknown()).optional(), // compose input (agent slugs/objects)
+    agent_slugs: z.array(z.string()).optional(), // the file shape (resolved to agents on load)
+    phases: z.array(PhaseSchema),
+    eval_slugs: z.array(z.string()).readonly().optional(),
+    input_types: z.array(z.string()).readonly().optional(),
+    output_types: z.array(z.string()).readonly().optional(),
+    // TODO(#194): plumbed end-to-end but NOT yet enforced — the runtime doesn't read this K-cap.
+    // A consumer reading it from the schema must not assume enforcement until #194 (the caller-driven
+    // examine⇄amend driver) lands. Tracked, non-blocking.
+    max_examine_rounds: z.number().optional(),
+    description: z.string().optional(),
+});
+// ── Skill — the package shape. Reconciles the two current shapes (SkillMeta typed + SkillRecord
+//    {slug;[k]:unknown} bag) into one. SHAPE-aligned only: determinism_ratio + fixtures are
+//    fields/artifacts the schema knows, but the OG rigid "fixtures pass ≥ threshold to PROMOTE"
+//    ceremony is deliberately NOT a schema invariant — promotion strictness is a separate, tunable
+//    policy. The fixture/determinism runner still enforces "fixtures pass + deterministic" in CI. ──
+export const NetworkGrantSchema = z.object({
+    allow: z.array(z.string()).default([]),
+    methods: z.array(z.string()).optional(),
+    max_requests: z.number().optional(),
+    max_bytes: z.number().optional(),
+});
+export const SkillPermissionSchema = z.object({
+    tier: z.number().optional(),
+    network: NetworkGrantSchema.optional(),
+});
+export const SkillSchema = z.object({
+    slug: z.string(),
+    version: z.number().optional(),
+    skill_type: z.string().optional(),
+    input_type: z.string().optional(),
+    output_type: z.string().optional(),
+    corpus: z.string().optional(),
+    determinism_ratio: z.number().optional(),
+    permission: SkillPermissionSchema.optional(),
+    description: z.string().optional(),
+    timeout_ms: z.number().optional(),
+    // a package declares fixtures (test suite + determinism meter) + its code. Present so skill_define
+    // is package-aware (meta + fixtures + code), not the retired flat {slug, domain, md}.
+    fixtures: z.array(z.unknown()).optional(),
+    code: z.string().optional(),
+    md: z.string().optional(),
+});
+// ── Eval — retire the {slug;[k]:unknown} bag; the loader validates eval files against this. ──
+export const EvalSchema = z.object({
+    slug: z.string(),
+    domain: z.string().optional(),
+    on_type: z.string().optional(),
+    non_empty_fields: z.array(z.string()).optional(),
+    // free-text description of the assertion the eval encodes (the runtime scores via on_type +
+    // non_empty_fields; `asserts` is the human-readable intent, not a machine list).
+    asserts: z.string().optional(),
+});
+// ── DomainType — the ONE source for the persisted type record. The loader's DomainTypeRecord and
+//    the registry's working projection both derive from this (no more three near-duplicate defs),
+//    and type_register's MCP surface is generated from it. version/status default (every on-disk
+//    file carries version:1 + status:"active"), so z.output has them present — the loader keys on
+//    `slug@version` and reads status — while z.input leaves them optional for the register op. ──
+export const DomainTypeStatusSchema = z.enum(["active", "deprecated", "retired"]);
+export const DomainTypeSchema = z.object({
+    slug: z.string(),
+    version: z.number().default(1),
+    extends: z.string(),
+    domain: z.string(),
+    status: DomainTypeStatusSchema.default("active"),
+    description: z.string().optional(),
+    schema: z.record(z.unknown()),
+    required_fields: z.array(z.string()).default([]),
+});
+function jsonTypeOf(schema) {
+    let s = schema;
+    // Unwrap the WRAPPER types (optional/default/nullable/readonly via `innerType`, effects via
+    // `schema`) to the inner type. Deliberately NOT `_def.type`: on a ZodArray that key holds the
+    // ELEMENT schema, so following it would descend into the array and report the element's scalar
+    // type — the bug that advertised `primitives: z.array(enum)` as "string" and broke agent_define.
+    // Bound is a deliberate safety cap, not a real limit: the genome's deepest field nests ~3 wrappers
+    // (e.g. `.array().readonly().optional()`), so 10 is unreachable in practice — it exists only so a
+    // future pathological/cyclic schema can't spin here. Raise it if a real field ever approaches it.
+    for (let i = 0; i < 10; i++) {
+        const def = s._def;
+        const inner = def?.innerType ?? def?.schema;
+        if (inner && inner instanceof z.ZodType) {
+            s = inner;
+            continue;
+        }
+        break;
+    }
+    if (s instanceof z.ZodString || s instanceof z.ZodEnum)
+        return "string";
+    if (s instanceof z.ZodNumber)
+        return "number";
+    if (s instanceof z.ZodBoolean)
+        return "boolean";
+    if (s instanceof z.ZodArray || s instanceof z.ZodTuple)
+        return "array";
+    return "object";
+}
+/** The MCP `properties` map (field → JSON type) for a genome class schema. */
+export function zodToMcpProps(schema) {
+    return Object.fromEntries(Object.entries(schema.shape).map(([k, v]) => [k, jsonTypeOf(v)]));
+}
+//# sourceMappingURL=genome_schema.js.map