@exaudeus/workrail 1.16.0 → 1.17.0

package/dist/application/use-cases/validate-workflow-registry.d.ts

@@ -0,0 +1,72 @@
+import type { Workflow } from '../../types/workflow.js';
+import type { WorkflowSource } from '../../types/workflow.js';
+import type { IWorkflowStorage } from '../../types/storage.js';
+import type { ValidationOutcome, ValidationOutcomePhase1a } from '../services/workflow-validation-pipeline.js';
+import { type ValidationPipelineDepsPhase1a, type SchemaError } from '../services/workflow-validation-pipeline.js';
+import type { ResolutionReason, VariantResolution, SourceRef } from '../../infrastructure/storage/workflow-resolution.js';
+import type { RawWorkflowFile, VariantKind } from './raw-workflow-file-scanner.js';
+export interface RegistrySnapshot {
+    readonly sources: readonly WorkflowSource[];
+    readonly rawFiles: readonly RawWorkflowFile[];
+    readonly candidates: readonly {
+        readonly sourceRef: SourceRef;
+        readonly workflows: readonly Workflow[];
+        readonly variantResolutions: ReadonlyMap<string, VariantResolution>;
+    }[];
+    readonly resolved: readonly {
+        readonly workflow: Workflow;
+        readonly resolvedBy: ResolutionReason;
+    }[];
+    readonly duplicates: readonly {
+        readonly workflowId: string;
+        readonly sources: readonly SourceRef[];
+    }[];
+}
+export type Tier1Outcome = {
+    readonly kind: 'tier1_unparseable';
+    readonly parseError: string;
+} | {
+    readonly kind: 'schema_failed';
+    readonly errors: readonly SchemaError[];
+} | {
+    readonly kind: 'structural_failed';
+    readonly issues: readonly string[];
+} | {
+    readonly kind: 'tier1_passed';
+};
+export interface ResolvedValidationEntry {
+    readonly workflowId: string;
+    readonly sourceRef: SourceRef;
+    readonly resolvedBy: ResolutionReason;
+    readonly outcome: ValidationOutcome | ValidationOutcomePhase1a;
+}
+export interface RawFileValidationEntry {
+    readonly filePath: string;
+    readonly relativeFilePath: string;
+    readonly sourceRef: SourceRef | undefined;
+    readonly workflowId: string | undefined;
+    readonly variantKind: VariantKind | undefined;
+    readonly isResolvedWinner: boolean;
+    readonly tier1Outcome: Tier1Outcome;
+}
+export interface DuplicateIdReport {
+    readonly workflowId: string;
+    readonly sourceRefs: readonly SourceRef[];
+    readonly isBundledProtection: boolean;
+}
+export interface RegistryValidationReport {
+    readonly totalRawFiles: number;
+    readonly totalResolvedWorkflows: number;
+    readonly validResolvedCount: number;
+    readonly invalidResolvedCount: number;
+    readonly tier1PassedRawFiles: number;
+    readonly tier1FailedRawFiles: number;
+    readonly duplicateIds: readonly DuplicateIdReport[];
+    readonly resolvedResults: readonly ResolvedValidationEntry[];
+    readonly rawFileResults: readonly RawFileValidationEntry[];
+    readonly isValid: boolean;
+}
+export interface RegistryValidatorDeps extends ValidationPipelineDepsPhase1a {
+}
+export declare function validateRegistry(snapshot: RegistrySnapshot, deps: RegistryValidatorDeps): RegistryValidationReport;
+export declare function buildRegistrySnapshot(storageInstances: readonly IWorkflowStorage[]): Promise<RegistrySnapshot>;

package/dist/application/use-cases/validate-workflow-registry.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRegistry = validateRegistry;
+exports.buildRegistrySnapshot = buildRegistrySnapshot;
+const workflow_validation_pipeline_js_1 = require("../services/workflow-validation-pipeline.js");
+const workflow_resolution_js_1 = require("../../infrastructure/storage/workflow-resolution.js");
+const raw_workflow_file_scanner_js_1 = require("./raw-workflow-file-scanner.js");
+const workflow_source_js_1 = require("../../types/workflow-source.js");
+const workflow_js_1 = require("../../types/workflow.js");
+function validateRegistry(snapshot, deps) {
+    const resolvedWinnerIds = new Set();
+    for (const { workflow } of snapshot.resolved) {
+        resolvedWinnerIds.add(workflow.definition.id);
+    }
+    const resolvedResults = [];
+    for (const { workflow, resolvedBy } of snapshot.resolved) {
+        const outcome = (0, workflow_validation_pipeline_js_1.validateWorkflowPhase1a)(workflow, deps);
+        resolvedResults.push({
+            workflowId: workflow.definition.id,
+            sourceRef: extractSourceRef(resolvedBy),
+            resolvedBy,
+            outcome,
+        });
+    }
+    const validResolvedCount = resolvedResults.filter(e => e.outcome.kind === 'phase1a_valid').length;
+    const rawFileResults = [];
+    for (const rawFile of snapshot.rawFiles) {
+        if (rawFile.kind === 'unparseable') {
+            rawFileResults.push({
+                filePath: rawFile.filePath,
+                relativeFilePath: rawFile.relativeFilePath,
+                sourceRef: findSourceRefForFile(rawFile.filePath, snapshot.sources),
+                workflowId: undefined,
+                variantKind: undefined,
+                isResolvedWinner: false,
+                tier1Outcome: { kind: 'tier1_unparseable', parseError: rawFile.error },
+            });
+        }
+        else {
+            const tier1Outcome = validateRawFileTier1(rawFile, deps);
+            const isWinner = resolvedWinnerIds.has(rawFile.definition.id);
+            rawFileResults.push({
+                filePath: rawFile.filePath,
+                relativeFilePath: rawFile.relativeFilePath,
+                sourceRef: findSourceRefForFile(rawFile.filePath, snapshot.sources),
+                workflowId: rawFile.definition.id,
+                variantKind: rawFile.variantKind,
+                isResolvedWinner: isWinner,
+                tier1Outcome,
+            });
+        }
+    }
+    const tier1PassedRawFiles = rawFileResults.filter(e => e.tier1Outcome.kind === 'tier1_passed').length;
+    const tier1FailedRawFiles = rawFileResults.length - tier1PassedRawFiles;
+    const resolvedByKindMap = new Map();
+    for (const { workflow, resolvedBy } of snapshot.resolved) {
+        resolvedByKindMap.set(workflow.definition.id, resolvedBy);
+    }
+    const duplicateIdReports = snapshot.duplicates.map(dup => ({
+        workflowId: dup.workflowId,
+        sourceRefs: dup.sources,
+        isBundledProtection: resolvedByKindMap.get(dup.workflowId)?.kind === 'bundled_protected',
+    }));
+    const hardErrorDuplicates = duplicateIdReports.filter(d => !d.isBundledProtection);
+    const isValid = validResolvedCount === snapshot.resolved.length &&
+        tier1FailedRawFiles === 0 &&
+        hardErrorDuplicates.length === 0;
+    return {
+        totalRawFiles: snapshot.rawFiles.length,
+        totalResolvedWorkflows: snapshot.resolved.length,
+        validResolvedCount,
+        invalidResolvedCount: snapshot.resolved.length - validResolvedCount,
+        tier1PassedRawFiles,
+        tier1FailedRawFiles,
+        duplicateIds: duplicateIdReports,
+        resolvedResults,
+        rawFileResults,
+        isValid,
+    };
+}
+function validateRawFileTier1(rawFile, deps) {
+    const fakeWorkflow = (0, workflow_js_1.createWorkflow)(rawFile.definition, { kind: 'bundled' });
+    const schemaResult = deps.schemaValidate(fakeWorkflow);
+    if (schemaResult.isErr()) {
+        return { kind: 'schema_failed', errors: schemaResult.error };
+    }
+    const structuralResult = deps.structuralValidate(fakeWorkflow);
+    if (structuralResult.isErr()) {
+        return { kind: 'structural_failed', issues: structuralResult.error };
+    }
+    return { kind: 'tier1_passed' };
+}
+function extractSourceRef(resolvedBy) {
+    switch (resolvedBy.kind) {
+        case 'unique':
+            return resolvedBy.sourceRef;
+        case 'source_priority':
+            return resolvedBy.winnerRef;
+        case 'bundled_protected':
+            return resolvedBy.bundledSourceRef;
+    }
+}
+function findSourceRefForFile(filePath, sources) {
+    for (let i = 0; i < sources.length; i++) {
+        const sourcePath = (0, workflow_source_js_1.getSourcePath)(sources[i]);
+        if (sourcePath && filePath.startsWith(sourcePath)) {
+            return i;
+        }
+    }
+    return undefined;
+}
+async function buildRegistrySnapshot(storageInstances) {
+    const sources = storageInstances.map(s => s.source);
+    const allRawFiles = [];
+    for (const source of sources) {
+        const sourcePath = (0, workflow_source_js_1.getSourcePath)(source);
+        if (!sourcePath)
+            continue;
+        try {
+            const rawFiles = await (0, raw_workflow_file_scanner_js_1.scanRawWorkflowFiles)(sourcePath);
+            allRawFiles.push(...rawFiles);
+        }
+        catch (_e) {
+        }
+    }
+    const candidates = [];
+    for (let i = 0; i < storageInstances.length; i++) {
+        const storage = storageInstances[i];
+        try {
+            const workflows = await storage.loadAllWorkflows();
+            const variantResolutions = deriveVariantResolutions(workflows, allRawFiles, sources[i]);
+            candidates.push({
+                sourceRef: i,
+                workflows,
+                variantResolutions,
+            });
+        }
+        catch (_e) {
+            candidates.push({
+                sourceRef: i,
+                workflows: [],
+                variantResolutions: new Map(),
+            });
+        }
+    }
+    const variantMap = new Map();
+    for (const { sourceRef, variantResolutions } of candidates) {
+        for (const [id, resolution] of variantResolutions.entries()) {
+            const existing = variantMap.get(id) ?? new Map();
+            const updated = new Map(existing);
+            updated.set(sourceRef, resolution);
+            variantMap.set(id, updated);
+        }
+    }
+    const candidatesForResolution = candidates.map(c => ({
+        sourceRef: c.sourceRef,
+        workflows: c.workflows,
+    }));
+    const resolved = (0, workflow_resolution_js_1.resolveWorkflowCandidates)(candidatesForResolution, variantMap);
+    const duplicates = (0, workflow_resolution_js_1.detectDuplicateIds)(candidatesForResolution);
+    return Object.freeze({
+        sources: Object.freeze(sources),
+        rawFiles: Object.freeze(allRawFiles),
+        candidates: Object.freeze(candidates),
+        resolved: Object.freeze(resolved),
+        duplicates: Object.freeze(duplicates),
+    });
+}
+function deriveVariantResolutions(loadedWorkflows, allRawFiles, source) {
+    const result = new Map();
+    const sourcePath = (0, workflow_source_js_1.getSourcePath)(source);
+    if (!sourcePath)
+        return result;
+    const rawFilesByWorkflowId = new Map();
+    for (const rawFile of allRawFiles) {
+        if (rawFile.kind !== 'parsed')
+            continue;
+        if (!rawFile.filePath.startsWith(sourcePath))
+            continue;
+        const id = rawFile.definition.id;
+        const existing = rawFilesByWorkflowId.get(id) ?? [];
+        rawFilesByWorkflowId.set(id, [...existing, rawFile]);
+    }
+    for (const workflow of loadedWorkflows) {
+        const id = workflow.definition.id;
+        const rawFilesForId = rawFilesByWorkflowId.get(id) ?? [];
+        if (rawFilesForId.length <= 1) {
+            result.set(id, { kind: 'only_variant' });
+        }
+        else {
+            const availableVariants = rawFilesForId.map(f => f.variantKind);
+            const selectedRaw = rawFilesForId.find(f => f.definition.id === id);
+            const selectedVariant = selectedRaw?.variantKind ?? 'standard';
+            if (selectedVariant === 'v2' || selectedVariant === 'agentic') {
+                result.set(id, {
+                    kind: 'feature_flag_selected',
+                    selectedVariant,
+                    availableVariants: availableVariants,
+                    enabledFlags: {
+                        v2Tools: selectedVariant === 'v2',
+                        agenticRoutines: selectedVariant === 'agentic',
+                    },
+                });
+            }
+            else {
+                result.set(id, {
+                    kind: 'precedence_fallback',
+                    selectedVariant,
+                    availableVariants: availableVariants,
+                });
+            }
+        }
+    }
+    return result;
+}

package/dist/application/validation.d.ts

@@ -1,5 +1,9 @@
+import type { Workflow } from '../types/workflow.js';
+import type { SchemaError } from './services/workflow-validation-pipeline.js';
+import { type Result } from 'neverthrow';
 export interface WorkflowValidationResult {
     valid: boolean;
     errors: string[];
 }
 export declare function validateWorkflow(workflow: unknown): WorkflowValidationResult;
+export declare function validateWorkflowSchema(workflow: Workflow): Result<Workflow, readonly SchemaError[]>;

package/dist/application/validation.js

@@ -4,10 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateWorkflow = validateWorkflow;
+exports.validateWorkflowSchema = validateWorkflowSchema;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const ajv_1 = __importDefault(require("ajv"));
 const enhanced_error_service_1 = require("./services/enhanced-error-service");
+const neverthrow_1 = require("neverthrow");
 const schemaPath = path_1.default.resolve(__dirname, '../../spec/workflow.schema.json');
 const schema = JSON.parse(fs_1.default.readFileSync(schemaPath, 'utf-8'));
 const ajv = new ajv_1.default({ allErrors: true, strict: false });
@@ -19,3 +21,17 @@ function validateWorkflow(workflow) {
         errors: ok ? [] : enhanced_error_service_1.EnhancedErrorService.enhanceErrors(validate.errors || [])
     };
 }
+function validateWorkflowSchema(workflow) {
+    const result = validateWorkflow(workflow.definition);
+    if (result.valid) {
+        return (0, neverthrow_1.ok)(workflow);
+    }
+    const ajvErrors = validate.errors || [];
+    const errors = ajvErrors.map(e => ({
+        instancePath: e.instancePath ?? '',
+        message: e.message,
+        keyword: e.keyword,
+        params: e.params,
+    }));
+    return (0, neverthrow_1.err)(errors);
+}

package/dist/cli/commands/validate.js

@@ -49,6 +49,21 @@ function executeValidateCommand(filePath, deps) {
                 ],
                 suggestions: result.suggestions ? [...result.suggestions] : undefined,
             });
+        case 'v1_compilation_failed':
+            return (0, cli_result_js_1.failure)(`V1 compilation failed: ${filePath}`, {
+                details: [result.message],
+                suggestions: ['Review the workflow definition and try again'],
+            });
+        case 'normalization_failed':
+            return (0, cli_result_js_1.failure)(`Normalization failed: ${filePath}`, {
+                details: [result.message],
+                suggestions: ['Review template/feature/ref definitions and try again'],
+            });
+        case 'executable_compilation_failed':
+            return (0, cli_result_js_1.failure)(`Executable compilation failed: ${filePath}`, {
+                details: [result.message],
+                suggestions: ['The normalized workflow has an internal conflict — ensure steps use exactly one prompt source'],
+            });
         default:
             return (0, assert_never_js_1.assertNever)(result);
     }

package/dist/cli.js

@@ -14,6 +14,8 @@ const server_js_1 = require("./mcp/server.js");
 const workflow_js_1 = require("./types/workflow.js");
 const validation_js_1 = require("./application/validation.js");
 const validate_workflow_file_js_1 = require("./application/use-cases/validate-workflow-file.js");
+const workflow_compiler_js_1 = require("./application/services/workflow-compiler.js");
+const v1_to_v2_shim_js_1 = require("./v2/read-only/v1-to-v2-shim.js");
 const interpret_result_js_1 = require("./cli/interpret-result.js");
 const index_js_1 = require("./cli/commands/index.js");
 const program = new commander_1.Command();
@@ -68,7 +70,8 @@ program
     await (0, container_js_1.initializeContainer)({ runtimeMode: { kind: 'cli' } });
     const terminator = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessTerminator);
     const validationEngine = container_js_1.container.resolve(tokens_js_1.DI.Infra.ValidationEngine);
-    const validateWorkflowFile = (0, validate_workflow_file_js_1.createValidateWorkflowFileUseCase)({
+    const compiler = new workflow_compiler_js_1.WorkflowCompiler();
+    const validateWorkflowFile = (0, validate_workflow_file_js_1.createValidateWorkflowFileUseCasePipeline)({
         resolvePath: path_1.default.resolve,
         existsSync: fs_1.default.existsSync,
         readFileSyncUtf8: (resolvedPath) => fs_1.default.readFileSync(resolvedPath, 'utf-8'),
@@ -76,6 +79,12 @@ program
         schemaValidate: (definition) => (0, validation_js_1.validateWorkflow)(definition),
         makeRuntimeWorkflow: (definition, resolvedPath) => (0, workflow_js_1.createWorkflow)(definition, (0, workflow_js_1.createCustomDirectorySource)(path_1.default.dirname(resolvedPath), 'CLI Validate')),
         validateRuntimeWorkflow: (workflow) => validationEngine.validateWorkflow(workflow),
+        validationPipelineDeps: {
+            schemaValidate: validation_js_1.validateWorkflowSchema,
+            structuralValidate: validationEngine.validateWorkflowStructureOnly.bind(validationEngine),
+            compiler,
+            normalizeToExecutable: v1_to_v2_shim_js_1.normalizeV1WorkflowToPinnedSnapshot,
+        },
     });
     const result = (0, index_js_1.executeValidateCommand)(filePath, { validateWorkflowFile });
     (0, interpret_result_js_1.interpretCliResult)(result, terminator);

package/dist/infrastructure/storage/caching-workflow-storage.d.ts

@@ -30,6 +30,7 @@ export declare class CachingCompositeWorkflowStorage implements ICompositeWorkfl
     constructor(inner: ICompositeWorkflowStorage, ttlMs: number);
     private isFresh;
     getSources(): readonly WorkflowSource[];
+    getStorageInstances(): readonly IWorkflowStorage[];
     loadAllWorkflows(): Promise<readonly Workflow[]>;
     getWorkflowById(id: string): Promise<Workflow | null>;
     listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;

package/dist/infrastructure/storage/caching-workflow-storage.js

@@ -85,6 +85,9 @@ class CachingCompositeWorkflowStorage {
     getSources() {
         return this.inner.getSources();
     }
+    getStorageInstances() {
+        return this.inner.getStorageInstances();
+    }
     async loadAllWorkflows() {
         if (this.isFresh(this.workflowCache)) {
             this.stats.hits += 1;

package/dist/infrastructure/storage/enhanced-multi-source-workflow-storage.d.ts

@@ -1,4 +1,4 @@
-import { ICompositeWorkflowStorage } from '../../types/storage';
+import { ICompositeWorkflowStorage, IWorkflowStorage } from '../../types/storage';
 import { Workflow, WorkflowSummary, WorkflowDefinition, WorkflowSource } from '../../types/workflow';
 import { GitWorkflowConfig } from './git-workflow-storage';
 import { RemoteWorkflowRegistryConfig } from './remote-workflow-storage';
@@ -31,6 +31,7 @@ export declare class EnhancedMultiSourceWorkflowStorage implements ICompositeWor
     private readonly config;
     constructor(config?: EnhancedMultiSourceConfig, featureFlagProvider?: IFeatureFlagProvider | null);
     getSources(): readonly WorkflowSource[];
+    getStorageInstances(): readonly IWorkflowStorage[];
     private initializeStorageSources;
     loadAllWorkflows(): Promise<readonly Workflow[]>;
     getWorkflowById(id: string): Promise<Workflow | null>;

package/dist/infrastructure/storage/enhanced-multi-source-workflow-storage.js

@@ -16,6 +16,7 @@ const remote_workflow_storage_1 = require("./remote-workflow-storage");
 const plugin_workflow_storage_1 = require("./plugin-workflow-storage");
 const feature_flags_1 = require("../../config/feature-flags");
 const logger_1 = require("../../utils/logger");
+const workflow_resolution_1 = require("./workflow-resolution");
 const logger = (0, logger_1.createLogger)('EnhancedMultiSourceWorkflowStorage');
 class EnhancedMultiSourceWorkflowStorage {
     constructor(config = {}, featureFlagProvider = null) {
@@ -40,6 +41,9 @@ class EnhancedMultiSourceWorkflowStorage {
     getSources() {
         return this.storageInstances.map(storage => storage.source);
     }
+    getStorageInstances() {
+        return this.storageInstances;
+    }
     initializeStorageSources(config) {
         const instances = [];
         if (!this.featureFlagProvider) {
@@ -127,36 +131,19 @@ class EnhancedMultiSourceWorkflowStorage {
         return instances;
     }
     async loadAllWorkflows() {
-        const allWorkflows = [];
-        const seenIds = new Set();
+        const candidates = [];
         for (let i = 0; i < this.storageInstances.length; i++) {
             const storage = this.storageInstances[i];
             try {
                 const workflows = await storage.loadAllWorkflows();
-                for (const workflow of workflows) {
-                    const id = workflow.definition.id;
-                    if (seenIds.has(id)) {
-                        const existingIndex = allWorkflows.findIndex((wf) => wf.definition.id === id);
-                        if (existingIndex >= 0) {
-                            const existing = allWorkflows[existingIndex];
-                            const isWr = id.startsWith('wr.');
-                            if (isWr && existing.source.kind === 'bundled') {
-                                continue;
-                            }
-                            allWorkflows[existingIndex] = workflow;
-                        }
-                    }
-                    else {
-                        allWorkflows.push(workflow);
-                        seenIds.add(id);
-                    }
-                }
+                candidates.push({ sourceRef: i, workflows });
             }
             catch (error) {
                 this.handleSourceError(`source-${i}`, error);
             }
         }
-        return allWorkflows;
+        const resolved = (0, workflow_resolution_1.resolveWorkflowCandidates)(candidates, new Map());
+        return resolved.map(r => r.workflow);
     }
     async getWorkflowById(id) {
         if (id.startsWith('wr.')) {

package/dist/infrastructure/storage/file-workflow-storage.d.ts

@@ -21,7 +21,6 @@ export declare class FileWorkflowStorage implements IWorkflowStorage {
     private workflowIndex;
     private indexExpires;
     constructor(directory: string, source: WorkflowSource, featureFlagProvider: IFeatureFlagProvider, options?: Omit<FileWorkflowStorageOptions, 'featureFlagProvider'>);
-    private findJsonFiles;
     private buildWorkflowIndex;
     private getWorkflowIndex;
     private loadDefinitionFromFile;

package/dist/infrastructure/storage/file-workflow-storage.js

@@ -12,6 +12,8 @@ const workflow_1 = require("../../types/workflow");
 const error_handler_1 = require("../../core/error-handler");
 const workflow_id_policy_1 = require("../../domain/workflow-id-policy");
 const storage_security_1 = require("../../utils/storage-security");
+const workflow_resolution_1 = require("./workflow-resolution");
+const raw_workflow_file_scanner_1 = require("../../application/use-cases/raw-workflow-file-scanner");
 function sanitizeId(id) {
     if (id.includes('\u0000')) {
         throw new error_handler_1.SecurityError('Null byte detected in identifier', 'sanitizeId');
@@ -40,28 +42,8 @@ class FileWorkflowStorage {
         this.indexCacheTTL = options.indexCacheTTLms ?? 30000;
         this.featureFlags = featureFlagProvider;
     }
-    async findJsonFiles(dir) {
-        const files = [];
-        async function scan(currentDir) {
-            const entries = await promises_1.default.readdir(currentDir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path_1.default.join(currentDir, entry.name);
-                if (entry.isDirectory()) {
-                    if (entry.name === 'examples') {
-                        continue;
-                    }
-                    await scan(fullPath);
-                }
-                else if (entry.isFile() && entry.name.endsWith('.json')) {
-                    files.push(fullPath);
-                }
-            }
-        }
-        await scan(dir);
-        return files;
-    }
     async buildWorkflowIndex() {
-        const allJsonFiles = await this.findJsonFiles(this.baseDirReal);
+        const allJsonFiles = await (0, raw_workflow_file_scanner_1.findWorkflowJsonFiles)(this.baseDirReal);
         const relativeFiles = allJsonFiles.map(f => path_1.default.relative(this.baseDirReal, f));
         const index = new Map();
         const idToFiles = new Map();
@@ -93,22 +75,19 @@ class FileWorkflowStorage {
                 continue;
             }
         }
+        const flags = {
+            v2Tools: this.featureFlags.isEnabled('v2Tools'),
+            agenticRoutines: this.featureFlags.isEnabled('agenticRoutines'),
+        };
         for (const [id, files] of idToFiles) {
-            let selected = files[0];
-            const isV2Enabled = this.featureFlags.isEnabled('v2Tools');
-            const isAgenticEnabled = this.featureFlags.isEnabled('agenticRoutines');
-            const v2Entry = files.find(f => f.file.includes('.v2.'));
-            const agenticEntry = files.find(f => f.file.includes('.agentic.'));
-            const standardEntry = files.find(f => !f.file.includes('.agentic.') && !f.file.includes('.v2.'));
-            if (isV2Enabled && v2Entry) {
-                selected = v2Entry;
-            }
-            else if (isAgenticEnabled && agenticEntry) {
-                selected = agenticEntry;
-            }
-            else if (standardEntry) {
-                selected = standardEntry;
-            }
+            const candidates = files.map(f => ({
+                variantKind: f.file.includes('.v2.') ? 'v2'
+                    : f.file.includes('.agentic.') ? 'agentic'
+                        : 'standard',
+                identifier: f.file,
+            }));
+            const selection = (0, workflow_resolution_1.selectVariant)(candidates, flags);
+            const selected = files.find(f => f.file === selection.selectedIdentifier) ?? files[0];
             const filePath = path_1.default.resolve(this.baseDirReal, selected.file);
             const stats = (0, fs_1.statSync)(filePath);
             index.set(id, {

package/dist/infrastructure/storage/schema-validating-workflow-storage.d.ts

@@ -19,6 +19,7 @@ export declare class SchemaValidatingCompositeWorkflowStorage implements ICompos
     constructor(inner: ICompositeWorkflowStorage);
     private validateDefinition;
     getSources(): readonly WorkflowSource[];
+    getStorageInstances(): readonly IWorkflowStorage[];
     loadAllWorkflows(): Promise<readonly Workflow[]>;
     getWorkflowById(id: string): Promise<Workflow | null>;
     listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;

package/dist/infrastructure/storage/schema-validating-workflow-storage.js

@@ -7,8 +7,13 @@ exports.SchemaValidatingCompositeWorkflowStorage = exports.SchemaValidatingWorkf
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const ajv_1 = __importDefault(require("ajv"));
+const workflow_1 = require("../../types/workflow");
 const error_handler_1 = require("../../core/error-handler");
 const workflow_id_policy_1 = require("../../domain/workflow-id-policy");
+const VALIDATION_ERROR_PREFIX = '[ValidationError]';
+function reportValidationFailure(workflowId, sourceKind, error) {
+    console.error(`${VALIDATION_ERROR_PREFIX} ${sourceKind}/${workflowId}: ${error}`);
+}
 class SchemaValidatingWorkflowStorage {
     constructor(inner) {
         this.inner = inner;
@@ -40,7 +45,7 @@ class SchemaValidatingWorkflowStorage {
                 }
             }
             catch (err) {
-                console.error(`[SchemaValidation] Workflow '${workflow.definition.id}' failed validation:`, err instanceof Error ? err.message : err);
+                reportValidationFailure(workflow.definition.id, workflow.source.kind, err instanceof Error ? err.message : String(err));
             }
         }
         return validWorkflows;
@@ -55,12 +60,13 @@ class SchemaValidatingWorkflowStorage {
             return workflow;
         }
         catch (err) {
-            console.error(`[SchemaValidation] Workflow '${id}' failed validation:`, err instanceof Error ? err.message : err);
+            reportValidationFailure(id, workflow.source.kind, err instanceof Error ? err.message : String(err));
             return null;
         }
     }
     async listWorkflowSummaries() {
-        return this.inner.listWorkflowSummaries();
+        const validated = await this.loadAllWorkflows();
+        return validated.map(workflow_1.toWorkflowSummary);
     }
     async save(definition) {
         this.validateDefinition(definition, this.source.kind);
@@ -92,6 +98,9 @@ class SchemaValidatingCompositeWorkflowStorage {
     getSources() {
         return this.inner.getSources();
     }
+    getStorageInstances() {
+        return this.inner.getStorageInstances();
+    }
     async loadAllWorkflows() {
         const workflows = await this.inner.loadAllWorkflows();
         const validWorkflows = [];
@@ -102,7 +111,7 @@ class SchemaValidatingCompositeWorkflowStorage {
                 }
             }
             catch (err) {
-                console.error(`[SchemaValidation] Workflow '${workflow.definition.id}' failed validation:`, err instanceof Error ? err.message : err);
+                reportValidationFailure(workflow.definition.id, workflow.source.kind, err instanceof Error ? err.message : String(err));
             }
         }
         return validWorkflows;
@@ -116,12 +125,13 @@ class SchemaValidatingCompositeWorkflowStorage {
             return workflow;
         }
         catch (err) {
-            console.error(`[SchemaValidation] Workflow '${id}' failed validation:`, err instanceof Error ? err.message : err);
+            reportValidationFailure(id, workflow.source.kind, err instanceof Error ? err.message : String(err));
             return null;
         }
     }
     async listWorkflowSummaries() {
-        return this.inner.listWorkflowSummaries();
+        const validated = await this.loadAllWorkflows();
+        return validated.map(workflow_1.toWorkflowSummary);
     }
     async save(definition) {
         this.validateDefinition(definition, 'project');