@actrun_ai/tastekit-core 0.1.0

package/dist/schemas/playbook.d.ts

@@ -0,0 +1,270 @@
+import { z } from 'zod';
+/**
+ * Playbook v1 Schema
+ *
+ * Runtime-agnostic execution plans with steps, checks, and escalations.
+ */
+export declare const PlaybookTriggerSchema: z.ZodObject<{
+    type: z.ZodEnum<["cron", "event", "manual"]>;
+    schedule: z.ZodOptional<z.ZodString>;
+    event_pattern: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "manual" | "cron" | "event";
+    schedule?: string | undefined;
+    event_pattern?: string | undefined;
+}, {
+    type: "manual" | "cron" | "event";
+    schedule?: string | undefined;
+    event_pattern?: string | undefined;
+}>;
+export declare const PlaybookInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    name: string;
+    required: boolean;
+    description?: string | undefined;
+}, {
+    type: string;
+    name: string;
+    description?: string | undefined;
+    required?: boolean | undefined;
+}>;
+export declare const PlaybookStepSchema: z.ZodObject<{
+    step_id: z.ZodString;
+    type: z.ZodEnum<["think", "tool", "transform", "write", "approval_gate"]>;
+    tool_ref: z.ZodOptional<z.ZodString>;
+    params_template: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    outputs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "write" | "think" | "tool" | "transform" | "approval_gate";
+    step_id: string;
+    tool_ref?: string | undefined;
+    params_template?: Record<string, any> | undefined;
+    outputs?: string[] | undefined;
+}, {
+    type: "write" | "think" | "tool" | "transform" | "approval_gate";
+    step_id: string;
+    tool_ref?: string | undefined;
+    params_template?: Record<string, any> | undefined;
+    outputs?: string[] | undefined;
+}>;
+export declare const PlaybookCheckSchema: z.ZodObject<{
+    check_id: z.ZodString;
+    type: z.ZodEnum<["taste", "safety", "format", "facts"]>;
+    rubric_ref: z.ZodOptional<z.ZodString>;
+    condition: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "taste" | "safety" | "format" | "facts";
+    check_id: string;
+    condition: string;
+    rubric_ref?: string | undefined;
+}, {
+    type: "taste" | "safety" | "format" | "facts";
+    check_id: string;
+    condition: string;
+    rubric_ref?: string | undefined;
+}>;
+export declare const PlaybookStopConditionSchema: z.ZodObject<{
+    condition: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    reason: string;
+    condition: string;
+}, {
+    reason: string;
+    condition: string;
+}>;
+export declare const PlaybookEscalationSchema: z.ZodObject<{
+    escalation_id: z.ZodString;
+    trigger: z.ZodString;
+    approval_ref: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    escalation_id: string;
+    trigger: string;
+    approval_ref: string;
+}, {
+    escalation_id: string;
+    trigger: string;
+    approval_ref: string;
+}>;
+export declare const PlaybookV1Schema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"playbook.v1">;
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    triggers: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["cron", "event", "manual"]>;
+        schedule: z.ZodOptional<z.ZodString>;
+        event_pattern: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "manual" | "cron" | "event";
+        schedule?: string | undefined;
+        event_pattern?: string | undefined;
+    }, {
+        type: "manual" | "cron" | "event";
+        schedule?: string | undefined;
+        event_pattern?: string | undefined;
+    }>, "many">;
+    inputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        name: string;
+        required: boolean;
+        description?: string | undefined;
+    }, {
+        type: string;
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }>, "many">;
+    steps: z.ZodArray<z.ZodObject<{
+        step_id: z.ZodString;
+        type: z.ZodEnum<["think", "tool", "transform", "write", "approval_gate"]>;
+        tool_ref: z.ZodOptional<z.ZodString>;
+        params_template: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        outputs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: "write" | "think" | "tool" | "transform" | "approval_gate";
+        step_id: string;
+        tool_ref?: string | undefined;
+        params_template?: Record<string, any> | undefined;
+        outputs?: string[] | undefined;
+    }, {
+        type: "write" | "think" | "tool" | "transform" | "approval_gate";
+        step_id: string;
+        tool_ref?: string | undefined;
+        params_template?: Record<string, any> | undefined;
+        outputs?: string[] | undefined;
+    }>, "many">;
+    checks: z.ZodArray<z.ZodObject<{
+        check_id: z.ZodString;
+        type: z.ZodEnum<["taste", "safety", "format", "facts"]>;
+        rubric_ref: z.ZodOptional<z.ZodString>;
+        condition: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "taste" | "safety" | "format" | "facts";
+        check_id: string;
+        condition: string;
+        rubric_ref?: string | undefined;
+    }, {
+        type: "taste" | "safety" | "format" | "facts";
+        check_id: string;
+        condition: string;
+        rubric_ref?: string | undefined;
+    }>, "many">;
+    stop_conditions: z.ZodArray<z.ZodObject<{
+        condition: z.ZodString;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        reason: string;
+        condition: string;
+    }, {
+        reason: string;
+        condition: string;
+    }>, "many">;
+    escalations: z.ZodArray<z.ZodObject<{
+        escalation_id: z.ZodString;
+        trigger: z.ZodString;
+        approval_ref: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        escalation_id: string;
+        trigger: string;
+        approval_ref: string;
+    }, {
+        escalation_id: string;
+        trigger: string;
+        approval_ref: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    name: string;
+    schema_version: "playbook.v1";
+    id: string;
+    inputs: {
+        type: string;
+        name: string;
+        required: boolean;
+        description?: string | undefined;
+    }[];
+    triggers: {
+        type: "manual" | "cron" | "event";
+        schedule?: string | undefined;
+        event_pattern?: string | undefined;
+    }[];
+    steps: {
+        type: "write" | "think" | "tool" | "transform" | "approval_gate";
+        step_id: string;
+        tool_ref?: string | undefined;
+        params_template?: Record<string, any> | undefined;
+        outputs?: string[] | undefined;
+    }[];
+    checks: {
+        type: "taste" | "safety" | "format" | "facts";
+        check_id: string;
+        condition: string;
+        rubric_ref?: string | undefined;
+    }[];
+    stop_conditions: {
+        reason: string;
+        condition: string;
+    }[];
+    escalations: {
+        escalation_id: string;
+        trigger: string;
+        approval_ref: string;
+    }[];
+}, {
+    description: string;
+    name: string;
+    schema_version: "playbook.v1";
+    id: string;
+    inputs: {
+        type: string;
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }[];
+    triggers: {
+        type: "manual" | "cron" | "event";
+        schedule?: string | undefined;
+        event_pattern?: string | undefined;
+    }[];
+    steps: {
+        type: "write" | "think" | "tool" | "transform" | "approval_gate";
+        step_id: string;
+        tool_ref?: string | undefined;
+        params_template?: Record<string, any> | undefined;
+        outputs?: string[] | undefined;
+    }[];
+    checks: {
+        type: "taste" | "safety" | "format" | "facts";
+        check_id: string;
+        condition: string;
+        rubric_ref?: string | undefined;
+    }[];
+    stop_conditions: {
+        reason: string;
+        condition: string;
+    }[];
+    escalations: {
+        escalation_id: string;
+        trigger: string;
+        approval_ref: string;
+    }[];
+}>;
+export type PlaybookV1 = z.infer<typeof PlaybookV1Schema>;
+export type PlaybookTrigger = z.infer<typeof PlaybookTriggerSchema>;
+export type PlaybookInput = z.infer<typeof PlaybookInputSchema>;
+export type PlaybookStep = z.infer<typeof PlaybookStepSchema>;
+export type PlaybookCheck = z.infer<typeof PlaybookCheckSchema>;
+export type PlaybookStopCondition = z.infer<typeof PlaybookStopConditionSchema>;
+export type PlaybookEscalation = z.infer<typeof PlaybookEscalationSchema>;
+//# sourceMappingURL=playbook.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"playbook.d.ts","sourceRoot":"","sources":["../../schemas/playbook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;EAIhC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAK9B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;EAM7B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAK9B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;EAGtC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;EAInC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/schemas/playbook.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+/**
+ * Playbook v1 Schema
+ *
+ * Runtime-agnostic execution plans with steps, checks, and escalations.
+ */
+export const PlaybookTriggerSchema = z.object({
+    type: z.enum(['cron', 'event', 'manual']),
+    schedule: z.string().optional().describe('Cron expression for scheduled triggers'),
+    event_pattern: z.string().optional().describe('Event pattern for event-based triggers'),
+});
+export const PlaybookInputSchema = z.object({
+    name: z.string(),
+    type: z.string().describe('Input type (string, number, resource, etc.)'),
+    required: z.boolean().default(true),
+    description: z.string().optional(),
+});
+export const PlaybookStepSchema = z.object({
+    step_id: z.string(),
+    type: z.enum(['think', 'tool', 'transform', 'write', 'approval_gate']),
+    tool_ref: z.string().optional().describe('Tool reference for tool steps'),
+    params_template: z.record(z.any()).optional().describe('Parameter template'),
+    outputs: z.array(z.string()).optional().describe('Output variable names'),
+});
+export const PlaybookCheckSchema = z.object({
+    check_id: z.string(),
+    type: z.enum(['taste', 'safety', 'format', 'facts']),
+    rubric_ref: z.string().optional().describe('Reference to evaluation rubric'),
+    condition: z.string().describe('Check condition expression'),
+});
+export const PlaybookStopConditionSchema = z.object({
+    condition: z.string().describe('Stop condition expression'),
+    reason: z.string().describe('Reason for stopping'),
+});
+export const PlaybookEscalationSchema = z.object({
+    escalation_id: z.string(),
+    trigger: z.string().describe('Trigger condition'),
+    approval_ref: z.string().describe('Reference to approval rule in guardrails'),
+});
+export const PlaybookV1Schema = z.object({
+    schema_version: z.literal('playbook.v1'),
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    triggers: z.array(PlaybookTriggerSchema),
+    inputs: z.array(PlaybookInputSchema),
+    steps: z.array(PlaybookStepSchema),
+    checks: z.array(PlaybookCheckSchema),
+    stop_conditions: z.array(PlaybookStopConditionSchema),
+    escalations: z.array(PlaybookEscalationSchema),
+});
+//# sourceMappingURL=playbook.js.map

package/dist/schemas/playbook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"playbook.js","sourceRoot":"","sources":["../../schemas/playbook.ts"],"names":[],"mappings":"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"}

package/dist/schemas/skills.d.ts

@@ -0,0 +1,320 @@
+import { z } from 'zod';
+/**
+ * Skills Manifest v1 Schema
+ *
+ * Metadata for the Skills library with progressive disclosure.
+ */
+export declare const SkillMetadataSchema: z.ZodObject<{
+    skill_id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    tags: z.ZodArray<z.ZodString, "many">;
+    risk_level: z.ZodEnum<["low", "med", "high"]>;
+    required_tools: z.ZodArray<z.ZodString, "many">;
+    compatible_runtimes: z.ZodArray<z.ZodString, "many">;
+    playbook_ref: z.ZodOptional<z.ZodString>;
+    /** Skill IDs that should complete before this skill runs */
+    prerequisites: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Skill IDs that consume this skill's output */
+    feeds_into: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Skill IDs that serve the same purpose (choose one) */
+    alternatives: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Pipeline phase: where this skill fits in a multi-step workflow */
+    pipeline_phase: z.ZodOptional<z.ZodString>;
+    /** Run in current context or spawn fresh subagent */
+    context_model: z.ZodOptional<z.ZodEnum<["inherit", "fork"]>>;
+    /** Suggested model for this skill */
+    model_hint: z.ZodOptional<z.ZodString>;
+    /** Skill provenance: public (open-source), private (personal), shared (team) */
+    source_type: z.ZodOptional<z.ZodEnum<["public", "private", "shared"]>>;
+    /** Skill IDs this skill depends on (validated during install) */
+    depends_on: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    name: string;
+    skill_id: string;
+    tags: string[];
+    risk_level: "low" | "med" | "high";
+    required_tools: string[];
+    compatible_runtimes: string[];
+    playbook_ref?: string | undefined;
+    prerequisites?: string[] | undefined;
+    feeds_into?: string[] | undefined;
+    alternatives?: string[] | undefined;
+    pipeline_phase?: string | undefined;
+    context_model?: "inherit" | "fork" | undefined;
+    model_hint?: string | undefined;
+    source_type?: "public" | "private" | "shared" | undefined;
+    depends_on?: string[] | undefined;
+}, {
+    description: string;
+    name: string;
+    skill_id: string;
+    tags: string[];
+    risk_level: "low" | "med" | "high";
+    required_tools: string[];
+    compatible_runtimes: string[];
+    playbook_ref?: string | undefined;
+    prerequisites?: string[] | undefined;
+    feeds_into?: string[] | undefined;
+    alternatives?: string[] | undefined;
+    pipeline_phase?: string | undefined;
+    context_model?: "inherit" | "fork" | undefined;
+    model_hint?: string | undefined;
+    source_type?: "public" | "private" | "shared" | undefined;
+    depends_on?: string[] | undefined;
+}>;
+export declare const SkillsManifestV1Schema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"skills_manifest.v1">;
+    skills: z.ZodArray<z.ZodObject<{
+        skill_id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        tags: z.ZodArray<z.ZodString, "many">;
+        risk_level: z.ZodEnum<["low", "med", "high"]>;
+        required_tools: z.ZodArray<z.ZodString, "many">;
+        compatible_runtimes: z.ZodArray<z.ZodString, "many">;
+        playbook_ref: z.ZodOptional<z.ZodString>;
+        /** Skill IDs that should complete before this skill runs */
+        prerequisites: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Skill IDs that consume this skill's output */
+        feeds_into: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Skill IDs that serve the same purpose (choose one) */
+        alternatives: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Pipeline phase: where this skill fits in a multi-step workflow */
+        pipeline_phase: z.ZodOptional<z.ZodString>;
+        /** Run in current context or spawn fresh subagent */
+        context_model: z.ZodOptional<z.ZodEnum<["inherit", "fork"]>>;
+        /** Suggested model for this skill */
+        model_hint: z.ZodOptional<z.ZodString>;
+        /** Skill provenance: public (open-source), private (personal), shared (team) */
+        source_type: z.ZodOptional<z.ZodEnum<["public", "private", "shared"]>>;
+        /** Skill IDs this skill depends on (validated during install) */
+        depends_on: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        name: string;
+        skill_id: string;
+        tags: string[];
+        risk_level: "low" | "med" | "high";
+        required_tools: string[];
+        compatible_runtimes: string[];
+        playbook_ref?: string | undefined;
+        prerequisites?: string[] | undefined;
+        feeds_into?: string[] | undefined;
+        alternatives?: string[] | undefined;
+        pipeline_phase?: string | undefined;
+        context_model?: "inherit" | "fork" | undefined;
+        model_hint?: string | undefined;
+        source_type?: "public" | "private" | "shared" | undefined;
+        depends_on?: string[] | undefined;
+    }, {
+        description: string;
+        name: string;
+        skill_id: string;
+        tags: string[];
+        risk_level: "low" | "med" | "high";
+        required_tools: string[];
+        compatible_runtimes: string[];
+        playbook_ref?: string | undefined;
+        prerequisites?: string[] | undefined;
+        feeds_into?: string[] | undefined;
+        alternatives?: string[] | undefined;
+        pipeline_phase?: string | undefined;
+        context_model?: "inherit" | "fork" | undefined;
+        model_hint?: string | undefined;
+        source_type?: "public" | "private" | "shared" | undefined;
+        depends_on?: string[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    schema_version: "skills_manifest.v1";
+    skills: {
+        description: string;
+        name: string;
+        skill_id: string;
+        tags: string[];
+        risk_level: "low" | "med" | "high";
+        required_tools: string[];
+        compatible_runtimes: string[];
+        playbook_ref?: string | undefined;
+        prerequisites?: string[] | undefined;
+        feeds_into?: string[] | undefined;
+        alternatives?: string[] | undefined;
+        pipeline_phase?: string | undefined;
+        context_model?: "inherit" | "fork" | undefined;
+        model_hint?: string | undefined;
+        source_type?: "public" | "private" | "shared" | undefined;
+        depends_on?: string[] | undefined;
+    }[];
+}, {
+    schema_version: "skills_manifest.v1";
+    skills: {
+        description: string;
+        name: string;
+        skill_id: string;
+        tags: string[];
+        risk_level: "low" | "med" | "high";
+        required_tools: string[];
+        compatible_runtimes: string[];
+        playbook_ref?: string | undefined;
+        prerequisites?: string[] | undefined;
+        feeds_into?: string[] | undefined;
+        alternatives?: string[] | undefined;
+        pipeline_phase?: string | undefined;
+        context_model?: "inherit" | "fork" | undefined;
+        model_hint?: string | undefined;
+        source_type?: "public" | "private" | "shared" | undefined;
+        depends_on?: string[] | undefined;
+    }[];
+}>;
+/**
+ * SKILL.md Structure (not enforced by schema, but documented here)
+ *
+ * Required sections:
+ * - Purpose (1-3 sentences)
+ * - When to use / When not to use
+ * - Inputs / Outputs
+ * - Procedure (steps referencing resources/scripts)
+ * - Quality checks
+ * - Guardrail notes
+ * - Progressive disclosure:
+ *   - Minimal context (always load)
+ *   - On invoke (load when skill is invoked)
+ *   - On demand resources (load only if needed)
+ */
+export type SkillsManifestV1 = z.infer<typeof SkillsManifestV1Schema>;
+export type SkillMetadata = z.infer<typeof SkillMetadataSchema>;
+export declare const SkillExecutionRecordSchema: z.ZodObject<{
+    skill_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    outcome: z.ZodEnum<["success", "failure", "partial"]>;
+    error_count: z.ZodNumber;
+    user_corrections: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+    user_feedback: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    skill_id: string;
+    run_id: string;
+    timestamp: string;
+    outcome: "success" | "failure" | "partial";
+    error_count: number;
+    user_corrections: number;
+    duration_ms: number;
+    user_feedback?: string | undefined;
+}, {
+    skill_id: string;
+    run_id: string;
+    timestamp: string;
+    outcome: "success" | "failure" | "partial";
+    error_count: number;
+    user_corrections: number;
+    duration_ms: number;
+    user_feedback?: string | undefined;
+}>;
+export declare const SkillPerformanceReportSchema: z.ZodObject<{
+    skill_id: z.ZodString;
+    total_runs: z.ZodNumber;
+    success_rate: z.ZodNumber;
+    avg_duration_ms: z.ZodNumber;
+    failure_reasons: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    trend: z.ZodEnum<["improving", "stable", "degrading"]>;
+}, "strip", z.ZodTypeAny, {
+    skill_id: string;
+    total_runs: number;
+    success_rate: number;
+    avg_duration_ms: number;
+    failure_reasons: Record<string, number>;
+    trend: "improving" | "stable" | "degrading";
+}, {
+    skill_id: string;
+    total_runs: number;
+    success_rate: number;
+    avg_duration_ms: number;
+    failure_reasons: Record<string, number>;
+    trend: "improving" | "stable" | "degrading";
+}>;
+export type SkillExecutionRecord = z.infer<typeof SkillExecutionRecordSchema>;
+export type SkillPerformanceReport = z.infer<typeof SkillPerformanceReportSchema>;
+export declare const SkillVersionSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    content_hash: z.ZodString;
+    timestamp: z.ZodString;
+    amendment_id: z.ZodOptional<z.ZodString>;
+    eval_score: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    version: number;
+    content_hash: string;
+    amendment_id?: string | undefined;
+    eval_score?: number | undefined;
+}, {
+    timestamp: string;
+    version: number;
+    content_hash: string;
+    amendment_id?: string | undefined;
+    eval_score?: number | undefined;
+}>;
+export declare const SkillVersionHistorySchema: z.ZodObject<{
+    skill_id: z.ZodString;
+    versions: z.ZodArray<z.ZodObject<{
+        version: z.ZodNumber;
+        content_hash: z.ZodString;
+        timestamp: z.ZodString;
+        amendment_id: z.ZodOptional<z.ZodString>;
+        eval_score: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        version: number;
+        content_hash: string;
+        amendment_id?: string | undefined;
+        eval_score?: number | undefined;
+    }, {
+        timestamp: string;
+        version: number;
+        content_hash: string;
+        amendment_id?: string | undefined;
+        eval_score?: number | undefined;
+    }>, "many">;
+    current: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    skill_id: string;
+    versions: {
+        timestamp: string;
+        version: number;
+        content_hash: string;
+        amendment_id?: string | undefined;
+        eval_score?: number | undefined;
+    }[];
+    current: number;
+}, {
+    skill_id: string;
+    versions: {
+        timestamp: string;
+        version: number;
+        content_hash: string;
+        amendment_id?: string | undefined;
+        eval_score?: number | undefined;
+    }[];
+    current: number;
+}>;
+export type SkillVersion = z.infer<typeof SkillVersionSchema>;
+export type SkillVersionHistory = z.infer<typeof SkillVersionHistorySchema>;
+export declare const ConstraintResultSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    constraint_id: z.ZodString;
+    message: z.ZodString;
+    details: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    passed: boolean;
+    constraint_id: string;
+    details?: any;
+}, {
+    message: string;
+    passed: boolean;
+    constraint_id: string;
+    details?: any;
+}>;
+export type ConstraintResult = z.infer<typeof ConstraintResultSchema>;
+//# sourceMappingURL=skills.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../schemas/skills.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;IAW9B,4DAA4D;;IAE5D,iDAAiD;;IAEjD,yDAAyD;;IAEzD,qEAAqE;;IAErE,qDAAqD;;IAErD,qCAAqC;;IAIrC,gFAAgF;;IAEhF,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjE,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;QApBjC,4DAA4D;;QAE5D,iDAAiD;;QAEjD,yDAAyD;;QAEzD,qEAAqE;;QAErE,qDAAqD;;QAErD,qCAAqC;;QAIrC,gFAAgF;;QAEhF,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOjE,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAMhE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;EASrC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;EAOvC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAMlF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;EAM7B,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIpC,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAM5E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;EAKjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}