@helmiq/crew 0.1.0

package/dist/config/index.d.ts

@@ -0,0 +1,7 @@
+export { loadYaml, projectConfigPath, loadProjectConfig } from './loader.js';
+export { loadConfig } from './resolver.js';
+export type { LoadedConfig, ResolverOptions, ResolvedSkills } from './resolver.js';
+export { resolveModel, resolveExecutionModel, resolveEvalModel } from './model-resolver.js';
+export type { ResolvedModel } from './model-resolver.js';
+export { ProjectConfigSchema, PersonaSpecSchema, EvaluationRubricSchema, LlmConfigSchema, ProviderSchema, SourceConfigSchema, WorkspaceConfigSchema, ContextRefSchema, SubAgentSchema, SimpleTaskSchema, CompositeTaskSchema, TaskSchema, CriterionSchema, CriterionWeightSchema, } from './schemas.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACnF,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5F,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,UAAU,EACV,eAAe,EACf,qBAAqB,GACtB,MAAM,cAAc,CAAC"}

package/dist/config/index.js

@@ -0,0 +1,4 @@
+export { loadYaml, projectConfigPath, loadProjectConfig } from './loader.js';
+export { loadConfig } from './resolver.js';
+export { resolveModel, resolveExecutionModel, resolveEvalModel } from './model-resolver.js';
+export { ProjectConfigSchema, PersonaSpecSchema, EvaluationRubricSchema, LlmConfigSchema, ProviderSchema, SourceConfigSchema, WorkspaceConfigSchema, ContextRefSchema, SubAgentSchema, SimpleTaskSchema, CompositeTaskSchema, TaskSchema, CriterionSchema, CriterionWeightSchema, } from './schemas.js';

package/dist/config/loader.d.ts

@@ -0,0 +1,16 @@
+import type { ZodSchema } from 'zod';
+import type { ProjectConfig } from '../types/index.js';
+/**
+ * Read a YAML file from disk and validate it against a Zod schema.
+ * Returns the parsed, validated object typed by the schema.
+ */
+export declare function loadYaml<T>(filePath: string, schema: ZodSchema<T>, label: string): Promise<T>;
+/**
+ * Resolve the path to the project config file within a workspace.
+ */
+export declare function projectConfigPath(workspacePath: string): string;
+/**
+ * Load and validate the project config from a workspace path.
+ */
+export declare function loadProjectConfig(workspacePath: string): Promise<ProjectConfig>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAGrC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;GAGG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAC9B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EACpB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,CAAC,CAAC,CAoCZ;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAGrF"}

package/dist/config/loader.js

@@ -0,0 +1,56 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { ZodError } from 'zod';
+import { ConfigNotFoundError, SchemaValidationError } from '../common/errors.js';
+/**
+ * Read a YAML file from disk and validate it against a Zod schema.
+ * Returns the parsed, validated object typed by the schema.
+ */
+export async function loadYaml(filePath, schema, label) {
+    let raw;
+    try {
+        raw = await readFile(filePath, 'utf-8');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT') {
+            throw new ConfigNotFoundError(`${label} not found at ${filePath}`, { cause: err });
+        }
+        throw new ConfigNotFoundError(`Failed to read ${label} at ${filePath}: ${String(err)}`, {
+            cause: err,
+        });
+    }
+    let parsed;
+    try {
+        parsed = parseYaml(raw);
+    }
+    catch (err) {
+        throw new SchemaValidationError(`${label} at ${filePath} contains invalid YAML`, err, {
+            cause: err,
+        });
+    }
+    try {
+        return schema.parse(parsed);
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            const issues = err.issues.map((i) => `  - ${i.path.join('.')}: ${i.message}`);
+            throw new SchemaValidationError(`${label} at ${filePath} failed schema validation:\n${issues.join('\n')}`, err.issues, { cause: err });
+        }
+        throw err;
+    }
+}
+/**
+ * Resolve the path to the project config file within a workspace.
+ */
+export function projectConfigPath(workspacePath) {
+    return join(workspacePath, '.crew', 'config');
+}
+/**
+ * Load and validate the project config from a workspace path.
+ */
+export async function loadProjectConfig(workspacePath) {
+    const { ProjectConfigSchema } = await import('./schemas.js');
+    return loadYaml(projectConfigPath(workspacePath), ProjectConfigSchema, 'Project config');
+}

package/dist/config/model-resolver.d.ts

@@ -0,0 +1,24 @@
+import type { LlmConfig } from '../types/index.js';
+export interface ResolvedModel {
+    alias: string;
+    provider: string;
+    concreteModel: string;
+    apiKeyEnv: string;
+}
+/**
+ * Resolve a model alias to its concrete provider details using the project's LLM config.
+ *
+ * Walks the provider registry to find which provider owns the alias,
+ * then validates the alias against allowed_models if configured.
+ */
+export declare function resolveModel(llmConfig: LlmConfig, alias: string): ResolvedModel;
+/**
+ * Resolve the execution model for a run, using the project default.
+ */
+export declare function resolveExecutionModel(llmConfig: LlmConfig): ResolvedModel;
+/**
+ * Resolve the self-evaluation model, falling back to the project default
+ * if the persona does not specify one.
+ */
+export declare function resolveEvalModel(llmConfig: LlmConfig, selfEvalModel?: string): ResolvedModel;
+//# sourceMappingURL=model-resolver.d.ts.map

package/dist/config/model-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-resolver.d.ts","sourceRoot":"","sources":["../../src/config/model-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGnD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,CAuB/E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,SAAS,GAAG,aAAa,CAEzE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,aAAa,CAG5F"}

package/dist/config/model-resolver.js

@@ -0,0 +1,39 @@
+import { ModelNotFoundError, ModelNotAllowedError } from '../common/errors.js';
+/**
+ * Resolve a model alias to its concrete provider details using the project's LLM config.
+ *
+ * Walks the provider registry to find which provider owns the alias,
+ * then validates the alias against allowed_models if configured.
+ */
+export function resolveModel(llmConfig, alias) {
+    for (const [providerName, provider] of Object.entries(llmConfig.providers)) {
+        const concreteModel = provider.models[alias];
+        if (concreteModel !== undefined) {
+            if (llmConfig.allowed_models && !llmConfig.allowed_models.includes(alias)) {
+                throw new ModelNotAllowedError(`Model '${alias}' exists in provider '${providerName}' but is not in the allowed_models list: [${llmConfig.allowed_models.join(', ')}]`);
+            }
+            return {
+                alias,
+                provider: providerName,
+                concreteModel,
+                apiKeyEnv: provider.api_key_env,
+            };
+        }
+    }
+    const allAliases = Object.values(llmConfig.providers).flatMap((p) => Object.keys(p.models));
+    throw new ModelNotFoundError(`Model alias '${alias}' not found in any provider. Available aliases: [${allAliases.join(', ')}]`);
+}
+/**
+ * Resolve the execution model for a run, using the project default.
+ */
+export function resolveExecutionModel(llmConfig) {
+    return resolveModel(llmConfig, llmConfig.default_model);
+}
+/**
+ * Resolve the self-evaluation model, falling back to the project default
+ * if the persona does not specify one.
+ */
+export function resolveEvalModel(llmConfig, selfEvalModel) {
+    const alias = selfEvalModel ?? llmConfig.default_model;
+    return resolveModel(llmConfig, alias);
+}

package/dist/config/resolver.d.ts

@@ -0,0 +1,22 @@
+import type { ProjectConfig, PersonaSpec, EvaluationRubric } from '../types/index.js';
+export type ResolvedSkills = Record<string, string>;
+export interface LoadedConfig {
+    project: ProjectConfig;
+    persona: PersonaSpec;
+    rubric: EvaluationRubric;
+    skills: ResolvedSkills;
+}
+export interface ResolverOptions {
+    workspacePath: string;
+    personaName: string;
+    /** Absolute path to the crew monorepo root (for skills). Defaults to 4 levels above this package. */
+    crewRepoPath?: string;
+    /** Absolute path to the @helmiq/crew package root (for defaults/rubrics). Defaults to 2 levels above dist/config. */
+    crewPackagePath?: string;
+}
+/**
+ * Load all configuration needed for a persona run:
+ * project config, persona spec, evaluation rubric, and resolved skill prompts.
+ */
+export declare function loadConfig(options: ResolverOptions): Promise<LoadedConfig>;
+//# sourceMappingURL=resolver.d.ts.map

package/dist/config/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/config/resolver.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAKtF,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEpD,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,cAAc,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,qGAAqG;IACrG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qHAAqH;IACrH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAkID;;;GAGG;AACH,wBAAsB,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,YAAY,CAAC,CAehF"}

package/dist/config/resolver.js

@@ -0,0 +1,115 @@
+import { access, readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { PersonaNotFoundError, RubricNotFoundError, SkillNotFoundError } from '../common/errors.js';
+import { loadYaml } from './loader.js';
+import { ProjectConfigSchema, PersonaSpecSchema, EvaluationRubricSchema } from './schemas.js';
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve a persona spec using the override chain:
+ * 1. {workspace}/.crew/agents/{name}/persona.yaml  (project override)
+ * 2. {crewRepo}/defaults/personas/{name}.persona.yaml  (default)
+ */
+async function resolvePersonaSpec(workspacePath, personaName, crewRepoPath) {
+    const projectPath = join(workspacePath, '.crew', 'agents', personaName, 'persona.yaml');
+    if (await fileExists(projectPath)) {
+        return loadYaml(projectPath, PersonaSpecSchema, `Persona spec '${personaName}'`);
+    }
+    const defaultPath = join(crewRepoPath, 'defaults', 'personas', `${personaName}.persona.yaml`);
+    if (await fileExists(defaultPath)) {
+        return loadYaml(defaultPath, PersonaSpecSchema, `Persona spec '${personaName}'`);
+    }
+    throw new PersonaNotFoundError(`Persona '${personaName}' not found. Searched:\n  - ${projectPath}\n  - ${defaultPath}`);
+}
+/**
+ * Resolve a rubric using the override chain:
+ * 1. {workspace}/.crew/rubrics/{rubricPath}  (project override)
+ * 2. {crewRepo}/defaults/{rubricPath}  (default)
+ *
+ * The rubricPath comes from the persona spec's evaluation.rubric field.
+ */
+async function resolveRubric(workspacePath, rubricPath, crewRepoPath) {
+    const projectRubricPath = join(workspacePath, '.crew', 'rubrics', rubricPath);
+    if (await fileExists(projectRubricPath)) {
+        return loadYaml(projectRubricPath, EvaluationRubricSchema, `Rubric '${rubricPath}'`);
+    }
+    const defaultRubricPath = join(crewRepoPath, 'defaults', rubricPath);
+    if (await fileExists(defaultRubricPath)) {
+        return loadYaml(defaultRubricPath, EvaluationRubricSchema, `Rubric '${rubricPath}'`);
+    }
+    throw new RubricNotFoundError(`Rubric '${rubricPath}' not found. Searched:\n  - ${projectRubricPath}\n  - ${defaultRubricPath}`);
+}
+/**
+ * Resolve a single skill name to its prompt content using the override chain:
+ * 1. {workspace}/.crew/skills/{name}/{name}.prompt.md  (project override)
+ * 2. {crewRepo}/packages/crew-skills/{name}/{name}.prompt.md  (default from skills package)
+ */
+async function resolveSkillPrompt(skillName, workspacePath, crewRepoPath) {
+    const fileName = `${skillName}.prompt.md`;
+    const wsPath = join(workspacePath, '.crew', 'skills', skillName, fileName);
+    if (await fileExists(wsPath))
+        return readFile(wsPath, 'utf-8');
+    const defaultPath = join(crewRepoPath, 'packages', 'crew-skills', skillName, fileName);
+    if (await fileExists(defaultPath))
+        return readFile(defaultPath, 'utf-8');
+    throw new SkillNotFoundError(`Skill '${skillName}' not found. Searched:\n  - ${wsPath}\n  - ${defaultPath}`);
+}
+/**
+ * Collect all unique skill names from the persona spec (persona-level skills,
+ * task-level skills, and sub-agent skills) and resolve each to prompt content.
+ */
+async function resolveSkills(spec, workspacePath, crewRepoPath) {
+    const skillNames = new Set(spec.persona.skills);
+    for (const task of Object.values(spec.persona.tasks)) {
+        if (task.mode === 'composite') {
+            for (const sub of task.sub_agents) {
+                skillNames.add(sub.skill);
+            }
+        }
+        else {
+            skillNames.add(task.skill);
+        }
+    }
+    const resolved = {};
+    for (const name of skillNames) {
+        resolved[name] = await resolveSkillPrompt(name, workspacePath, crewRepoPath);
+    }
+    return resolved;
+}
+/**
+ * Resolve to the crew monorepo root (4 levels up from dist/config/).
+ * Used for skills resolution -- skills live at {repoRoot}/packages/crew-skills/.
+ */
+function defaultCrewRepoPath() {
+    return resolve(import.meta.dirname, '..', '..', '..', '..');
+}
+/**
+ * Resolve to the @helmiq/crew package root (2 levels up from dist/config/).
+ * Used for defaults resolution -- defaults/ and rubrics live at {packageRoot}/defaults/.
+ */
+function defaultPackagePath() {
+    return resolve(import.meta.dirname, '..', '..');
+}
+/**
+ * Load all configuration needed for a persona run:
+ * project config, persona spec, evaluation rubric, and resolved skill prompts.
+ */
+export async function loadConfig(options) {
+    const { workspacePath, personaName } = options;
+    const crewRepoPath = options.crewRepoPath ?? defaultCrewRepoPath();
+    const packagePath = options.crewPackagePath ?? defaultPackagePath();
+    const configPath = join(workspacePath, '.crew', 'config');
+    const project = await loadYaml(configPath, ProjectConfigSchema, 'Project config');
+    const persona = await resolvePersonaSpec(workspacePath, personaName, packagePath);
+    const skills = await resolveSkills(persona, workspacePath, crewRepoPath);
+    const rubricPath = persona.persona.evaluation.rubric;
+    const rubric = await resolveRubric(workspacePath, rubricPath, packagePath);
+    return { project, persona, rubric, skills };
+}

package/dist/config/schemas.d.ts

@@ -0,0 +1,266 @@
+import { z } from 'zod';
+export declare const ProviderSchema: z.ZodObject<{
+    api_key_env: z.ZodString;
+    models: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export declare const LlmConfigSchema: z.ZodObject<{
+    default_model: z.ZodString;
+    allowed_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        api_key_env: z.ZodString;
+        models: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const SourceConfigSchema: z.ZodObject<{
+    repo: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+export declare const WorkspaceConfigSchema: z.ZodObject<{
+    path: z.ZodString;
+    work: z.ZodString;
+    runs: z.ZodString;
+}, z.core.$strip>;
+export declare const ProjectConfigSchema: z.ZodObject<{
+    project: z.ZodObject<{
+        name: z.ZodString;
+        key: z.ZodString;
+    }, z.core.$strip>;
+    workspace: z.ZodObject<{
+        path: z.ZodString;
+        work: z.ZodString;
+        runs: z.ZodString;
+    }, z.core.$strip>;
+    source: z.ZodObject<{
+        repo: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>;
+    llm: z.ZodObject<{
+        default_model: z.ZodString;
+        allowed_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+            api_key_env: z.ZodString;
+            models: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ContextRefSchema: z.ZodObject<{
+    artifact: z.ZodString;
+    scope: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    when: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SubAgentSchema: z.ZodObject<{
+    name: z.ZodString;
+    skill: z.ZodString;
+    reads: z.ZodArray<z.ZodString>;
+    produces: z.ZodString;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    max_iterations: z.ZodOptional<z.ZodNumber>;
+    gate: z.ZodOptional<z.ZodString>;
+    on_fail: z.ZodOptional<z.ZodString>;
+    max_loops: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const SimpleTaskSchema: z.ZodObject<{
+    mode: z.ZodLiteral<"simple">;
+    trigger: z.ZodArray<z.ZodEnum<{
+        manual: "manual";
+        scheduled: "scheduled";
+        event: "event";
+    }>>;
+    skill: z.ZodString;
+    reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    produces: z.ZodString;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    published_artifact: z.ZodOptional<z.ZodString>;
+    quality_gate: z.ZodOptional<z.ZodEnum<{
+        "self-eval": "self-eval";
+        "human-review": "human-review";
+        "multi-model": "multi-model";
+    }>>;
+}, z.core.$strip>;
+export declare const CompositeTaskSchema: z.ZodObject<{
+    mode: z.ZodLiteral<"composite">;
+    trigger: z.ZodArray<z.ZodEnum<{
+        manual: "manual";
+        scheduled: "scheduled";
+        event: "event";
+    }>>;
+    sub_agents: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        skill: z.ZodString;
+        reads: z.ZodArray<z.ZodString>;
+        produces: z.ZodString;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        max_iterations: z.ZodOptional<z.ZodNumber>;
+        gate: z.ZodOptional<z.ZodString>;
+        on_fail: z.ZodOptional<z.ZodString>;
+        max_loops: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    published_artifact: z.ZodString;
+    quality_gate: z.ZodOptional<z.ZodEnum<{
+        "self-eval": "self-eval";
+        "human-review": "human-review";
+        "multi-model": "multi-model";
+    }>>;
+}, z.core.$strip>;
+export declare const TaskSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"simple">;
+    trigger: z.ZodArray<z.ZodEnum<{
+        manual: "manual";
+        scheduled: "scheduled";
+        event: "event";
+    }>>;
+    skill: z.ZodString;
+    reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    produces: z.ZodString;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    published_artifact: z.ZodOptional<z.ZodString>;
+    quality_gate: z.ZodOptional<z.ZodEnum<{
+        "self-eval": "self-eval";
+        "human-review": "human-review";
+        "multi-model": "multi-model";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"composite">;
+    trigger: z.ZodArray<z.ZodEnum<{
+        manual: "manual";
+        scheduled: "scheduled";
+        event: "event";
+    }>>;
+    sub_agents: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        skill: z.ZodString;
+        reads: z.ZodArray<z.ZodString>;
+        produces: z.ZodString;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        max_iterations: z.ZodOptional<z.ZodNumber>;
+        gate: z.ZodOptional<z.ZodString>;
+        on_fail: z.ZodOptional<z.ZodString>;
+        max_loops: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    published_artifact: z.ZodString;
+    quality_gate: z.ZodOptional<z.ZodEnum<{
+        "self-eval": "self-eval";
+        "human-review": "human-review";
+        "multi-model": "multi-model";
+    }>>;
+}, z.core.$strip>], "mode">;
+export declare const PersonaSpecSchema: z.ZodObject<{
+    persona: z.ZodObject<{
+        name: z.ZodString;
+        identity: z.ZodObject<{
+            role: z.ZodString;
+        }, z.core.$strip>;
+        skills: z.ZodArray<z.ZodString>;
+        perception: z.ZodObject<{
+            always_read: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                artifact: z.ZodString;
+                scope: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                when: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            per_task: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+                artifact: z.ZodString;
+                scope: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                when: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        tasks: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"simple">;
+            trigger: z.ZodArray<z.ZodEnum<{
+                manual: "manual";
+                scheduled: "scheduled";
+                event: "event";
+            }>>;
+            skill: z.ZodString;
+            reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            produces: z.ZodString;
+            tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            published_artifact: z.ZodOptional<z.ZodString>;
+            quality_gate: z.ZodOptional<z.ZodEnum<{
+                "self-eval": "self-eval";
+                "human-review": "human-review";
+                "multi-model": "multi-model";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"composite">;
+            trigger: z.ZodArray<z.ZodEnum<{
+                manual: "manual";
+                scheduled: "scheduled";
+                event: "event";
+            }>>;
+            sub_agents: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                skill: z.ZodString;
+                reads: z.ZodArray<z.ZodString>;
+                produces: z.ZodString;
+                tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                max_iterations: z.ZodOptional<z.ZodNumber>;
+                gate: z.ZodOptional<z.ZodString>;
+                on_fail: z.ZodOptional<z.ZodString>;
+                max_loops: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            published_artifact: z.ZodString;
+            quality_gate: z.ZodOptional<z.ZodEnum<{
+                "self-eval": "self-eval";
+                "human-review": "human-review";
+                "multi-model": "multi-model";
+            }>>;
+        }, z.core.$strip>], "mode">>;
+        tools: z.ZodObject<{
+            permitted: z.ZodArray<z.ZodString>;
+            denied: z.ZodArray<z.ZodString>;
+            writable_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        cadence: z.ZodObject<{
+            scheduled: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cron: z.ZodString;
+                task: z.ZodString;
+            }, z.core.$strip>>>;
+            event: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                on: z.ZodString;
+                task: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        evaluation: z.ZodObject<{
+            self_eval_model: z.ZodOptional<z.ZodString>;
+            rubric: z.ZodString;
+            multi_model: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CriterionWeightSchema: z.ZodEnum<{
+    blocking: "blocking";
+    important: "important";
+    advisory: "advisory";
+}>;
+export declare const CriterionSchema: z.ZodObject<{
+    name: z.ZodString;
+    weight: z.ZodEnum<{
+        blocking: "blocking";
+        important: "important";
+        advisory: "advisory";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const EvaluationRubricSchema: z.ZodObject<{
+    rubric: z.ZodObject<{
+        artifact_type: z.ZodString;
+        scoring_scale: z.ZodOptional<z.ZodNumber>;
+        pass_threshold: z.ZodNumber;
+        aggregate_threshold: z.ZodOptional<z.ZodNumber>;
+        divergence_threshold: z.ZodOptional<z.ZodNumber>;
+        models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        criteria: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            weight: z.ZodEnum<{
+                blocking: "blocking";
+                important: "important";
+                advisory: "advisory";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/config/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/config/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;iBAGzB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;iBAYzB,CAAC;AAEJ,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;iBAIhC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;iBAQ9B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;iBAK3B,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;iBAUzB,CAAC;AAKH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;iBAS3B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;iBAM9B,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAAwE,CAAC;AAEhG,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2B5B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;EAAgD,CAAC;AAEnF,eAAO,MAAM,eAAe;;;;;;;;iBAI1B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;iBAUjC,CAAC"}