@exaudeus/workrail 1.16.0 → 1.17.0

package/dist/application/services/compiler/feature-registry.js

@@ -11,6 +11,24 @@ const FEATURE_DEFINITIONS = [
             ],
         ],
     },
+    {
+        id: 'wr.features.subagent_guidance',
+        constraints: [
+            'Use the WorkRail Executor as the only subagent model. Do not refer to or rely on named Builder, Researcher, or other identities.',
+            'The main agent owns strategy, decisions, synthesis, and final outputs. Subagents provide independent cognitive perspectives only.',
+            [
+                { kind: 'ref', refId: 'wr.refs.parallelize_cognition_serialize_synthesis' },
+            ],
+        ],
+        procedure: [
+            'When delegating to WorkRail Executors, provide each with a clear non-overlapping focus and the shared fact packet or context as primary truth.',
+            'After receiving parallel subagent outputs, synthesize them yourself — do not let any single subagent output become the canonical answer without main-agent review.',
+        ],
+        verify: [
+            'All delegated outputs were synthesized by the main agent, not adopted verbatim.',
+            'No subagent was given final decision authority over canonical findings, recommendations, or artifacts.',
+        ],
+    },
 ];
 function createFeatureRegistry() {
     const byId = new Map(FEATURE_DEFINITIONS.map(f => [f.id, f]));

package/dist/application/services/compiler/prompt-blocks.js

@@ -91,8 +91,9 @@ function resolveStepPromptBlocks(step) {
             cause: renderResult.error,
         });
     }
+    const { promptBlocks: _stripped, ...rest } = step;
     return (0, neverthrow_1.ok)({
-        ...step,
+        ...rest,
         prompt: renderResult.value,
     });
 }

package/dist/application/services/compiler/ref-registry.js

@@ -22,6 +22,42 @@ const REF_CONTENT = {
         '- Use workspace-scoped queries to find related past work',
         '- Do not block on Memory failures — proceed without prior context if unavailable',
     ].join('\n'),
+    'wr.refs.notes_first_durability': [
+        'Durability rules (notes-first):',
+        '- Use output.notesMarkdown as the primary durable record for every step',
+        '- Keep execution truth in notes and explicit context variables, not in markdown sidecar files',
+        '- Human-facing artifacts (review docs, plans) are for readability only — they are NOT required workflow memory',
+        '- If a chat rewind occurs, the durable notes and context variables survive; sidecar files may not',
+        '- Always record key decisions, findings, and rationale in notesMarkdown before advancing',
+    ].join('\n'),
+    'wr.refs.synthesis_under_disagreement': [
+        'Synthesis rules when parallel outputs disagree:',
+        '- Treat disagreement as first-class work — never handwave contradictory outputs',
+        '- If 2+ parallel outputs flag the same issue at the same severity, treat it as validated',
+        '- If the same issue is flagged at different severities, default to the higher severity unless the lower-severity position includes specific counter-evidence',
+        '- If one output flags an issue and others are silent, investigate it but do not automatically block unless it is clearly critical',
+        '- If one output says false positive and another says valid issue, require explicit main-agent adjudication in notes before finalization',
+        '- If outputs show material disagreement, findings override any preliminary recommendation until the disagreement is reconciled',
+        '- Document every resolved contradiction with its resolution rationale',
+    ].join('\n'),
+    'wr.refs.parallelize_cognition_serialize_synthesis': [
+        'Parallelism rules:',
+        '- Parallelize independent cognition: context gathering, hypothesis generation, audit routines, and reviewer families can run simultaneously',
+        '- Serialize synthesis: merging parallel outputs, resolving contradictions, making canonical decisions, and writing final artifacts must happen sequentially by the main agent',
+        '- Never let a parallel subagent finalize or commit to a canonical answer — the main agent owns synthesis and final decisions',
+        '- Prefer one compact targeted bundle over multiple small sequential delegation moments',
+        '- When spawning parallel executors, give each a clear, non-overlapping focus area',
+    ].join('\n'),
+    'wr.refs.adversarial_challenge_rules': [
+        'Adversarial challenge rules:',
+        '- Actively try to break the current leading position — do not just look for confirming evidence',
+        '- For each finding or conclusion, ask: what evidence would disprove this? Is that evidence missing or present?',
+        '- If the challenge cannot materially weaken the position, the position is strengthened',
+        '- If the challenge reveals a genuine weakness, it must be recorded as a finding and the position must be updated',
+        '- Do not soften findings to avoid conflict — severity should reflect actual risk, not social comfort',
+        '- Challenge severity inflation as well as severity deflation — false positives waste as much attention as false negatives',
+        '- If 2+ independent challengers raise the same serious concern, treat it as blocking by default',
+    ].join('\n'),
 };
 function createRefRegistry() {
     const knownIds = Object.keys(REF_CONTENT);

package/dist/application/services/validation-engine.d.ts

@@ -40,6 +40,7 @@ export declare class ValidationEngine {
     private formatDefaultContainsMessage;
     validateLoopStep(step: LoopStepDefinition, workflow: Workflow): ValidationResult;
     validateWorkflow(workflow: Workflow): ValidationResult;
+    validateWorkflowStructureOnly(workflow: Workflow): Result<Workflow, readonly string[]>;
     private collectQuotedJsonValidationMessageWarnings;
     private collectValidationRuleMessages;
     private isValidVariableName;

package/dist/application/services/validation-engine.js

@@ -490,6 +490,13 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
                     issues.push(`Step '${step.id}' must have prompt, promptBlocks, or templateCall`);
                     suggestions.push('Add a prompt string, structured promptBlocks, or a templateCall to each step');
                 }
+                const typedStep = step;
+                const promptSourceCount = (typedStep.prompt ? 1 : 0) +
+                    (typedStep.promptBlocks ? 1 : 0) +
+                    (typedStep.templateCall ? 1 : 0);
+                if (promptSourceCount > 1) {
+                    issues.push(`Step '${step.id}' declares multiple prompt sources (prompt, promptBlocks, templateCall) — use exactly one`);
+                }
                 this.collectQuotedJsonValidationMessageWarnings(step, `Step '${step.id}'`, warnings);
                 const callValidation = this.validateStepFunctionCalls(step, workflow.definition.functionDefinitions || []);
                 if (!callValidation.valid) {
@@ -527,6 +534,13 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
             info: info.length > 0 ? info : undefined
         };
     }
+    validateWorkflowStructureOnly(workflow) {
+        const result = this.validateWorkflow(workflow);
+        if (result.valid) {
+            return (0, neverthrow_1.ok)(workflow);
+        }
+        return (0, neverthrow_1.err)(result.issues);
+    }
     collectQuotedJsonValidationMessageWarnings(stepLike, prefix, warnings) {
         const criteria = stepLike?.validationCriteria;
         if (!criteria)

package/dist/application/services/workflow-validation-pipeline.d.ts

@@ -0,0 +1,96 @@
+import type { Workflow } from '../../types/workflow.js';
+import type { DomainError } from '../../domain/execution/error.js';
+import type { WorkflowCompiler, CompiledWorkflow } from './workflow-compiler.js';
+import type { WorkflowInterpreter } from './workflow-interpreter.js';
+import { type Result } from 'neverthrow';
+import type { CompiledWorkflowSnapshotV1 } from '../../v2/durable-core/schemas/compiled-workflow/index.js';
+import type { StartabilityFailure } from '../../v2/durable-core/domain/start-construction.js';
+export interface SchemaError {
+    readonly instancePath: string;
+    readonly message?: string;
+    readonly keyword?: string;
+    readonly params?: unknown;
+}
+export type ExecutableCompiledWorkflowSnapshot = Extract<CompiledWorkflowSnapshotV1, {
+    sourceKind: 'v1_pinned';
+}>;
+export type ValidationOutcomePhase1a = {
+    readonly kind: 'schema_failed';
+    readonly workflowId: string;
+    readonly errors: readonly SchemaError[];
+} | {
+    readonly kind: 'structural_failed';
+    readonly workflowId: string;
+    readonly issues: readonly string[];
+} | {
+    readonly kind: 'v1_compilation_failed';
+    readonly workflowId: string;
+    readonly cause: DomainError;
+} | {
+    readonly kind: 'normalization_failed';
+    readonly workflowId: string;
+    readonly cause: DomainError;
+} | {
+    readonly kind: 'executable_compilation_failed';
+    readonly workflowId: string;
+    readonly cause: DomainError;
+} | {
+    readonly kind: 'phase1a_valid';
+    readonly workflowId: string;
+    readonly snapshot: ExecutableCompiledWorkflowSnapshot;
+};
+export type ValidationOutcome = {
+    readonly kind: 'schema_failed';
+    readonly workflowId: string;
+    readonly errors: readonly SchemaError[];
+} | {
+    readonly kind: 'structural_failed';
+    readonly workflowId: string;
+    readonly issues: readonly string[];
+} | {
+    readonly kind: 'v1_compilation_failed';
+    readonly workflowId: string;
+    readonly cause: DomainError;
+} | {
+    readonly kind: 'normalization_failed';
+    readonly workflowId: string;
+    readonly cause: DomainError;
+} | {
+    readonly kind: 'round_trip_failed';
+    readonly workflowId: string;
+    readonly cause: string;
+} | {
+    readonly kind: 'v2_compilation_failed';
+    readonly workflowId: string;
+    readonly cause: DomainError;
+} | {
+    readonly kind: 'startability_failed';
+    readonly workflowId: string;
+    readonly reason: StartabilityFailure;
+} | {
+    readonly kind: 'valid';
+    readonly validated: ValidatedWorkflow;
+};
+export interface ValidatedWorkflow {
+    readonly kind: 'validated_workflow';
+    readonly source: Workflow;
+    readonly executable: any;
+    readonly compiledV1: CompiledWorkflow;
+    readonly compiledExecutable: any;
+}
+export interface ValidationPipelineDepsPhase1a {
+    readonly schemaValidate: (workflow: Workflow) => Result<Workflow, readonly SchemaError[]>;
+    readonly structuralValidate: (workflow: Workflow) => Result<Workflow, readonly string[]>;
+    readonly compiler: WorkflowCompiler;
+    readonly normalizeToExecutable: (workflow: Workflow) => Result<ExecutableCompiledWorkflowSnapshot, DomainError>;
+}
+export interface ValidationPipelineDeps extends ValidationPipelineDepsPhase1a {
+    readonly interpreter: WorkflowInterpreter;
+    readonly resolveFirstStep: (authoredWorkflow: Workflow, pinnedSnapshot: Extract<CompiledWorkflowSnapshotV1, {
+        sourceKind: 'v1_pinned';
+    }>) => Result<{
+        readonly id: string;
+    }, StartabilityFailure>;
+}
+export declare function validateWorkflowPhase1a(workflow: Workflow, deps: ValidationPipelineDepsPhase1a): ValidationOutcomePhase1a;
+export declare function validateWorkflow(workflow: Workflow, deps: ValidationPipelineDeps): ValidationOutcome;

package/dist/application/services/workflow-validation-pipeline.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWorkflowPhase1a = validateWorkflowPhase1a;
+exports.validateWorkflow = validateWorkflow;
+const workflow_js_1 = require("../../types/workflow.js");
+const workflow_source_js_1 = require("../../types/workflow-source.js");
+const workflow_definition_js_1 = require("../../types/workflow-definition.js");
+const neverthrow_1 = require("neverthrow");
+function validateWorkflowPhase1a(workflow, deps) {
+    const workflowId = workflow.definition.id;
+    const schemaResult = deps.schemaValidate(workflow);
+    if (schemaResult.isErr()) {
+        return { kind: 'schema_failed', workflowId, errors: schemaResult.error };
+    }
+    const structuralResult = deps.structuralValidate(workflow);
+    if (structuralResult.isErr()) {
+        return { kind: 'structural_failed', workflowId, issues: structuralResult.error };
+    }
+    const v1CompilationResult = deps.compiler.compile(workflow);
+    if (v1CompilationResult.isErr()) {
+        return { kind: 'v1_compilation_failed', workflowId, cause: v1CompilationResult.error };
+    }
+    const normalizationResult = deps.normalizeToExecutable(workflow);
+    if (normalizationResult.isErr()) {
+        return { kind: 'normalization_failed', workflowId, cause: normalizationResult.error };
+    }
+    const snapshot = normalizationResult.value;
+    if ((0, workflow_definition_js_1.hasWorkflowDefinitionShape)(snapshot.definition)) {
+        const executableWorkflow = (0, workflow_js_1.createWorkflow)(snapshot.definition, (0, workflow_source_js_1.createBundledSource)());
+        const execCompileResult = deps.compiler.compile(executableWorkflow);
+        if (execCompileResult.isErr()) {
+            return { kind: 'executable_compilation_failed', workflowId, cause: execCompileResult.error };
+        }
+    }
+    return { kind: 'phase1a_valid', workflowId, snapshot };
+}
+function validateWorkflow(workflow, deps) {
+    const workflowId = workflow.definition.id;
+    const phase1aOutcome = validateWorkflowPhase1a(workflow, deps);
+    if (phase1aOutcome.kind !== 'phase1a_valid') {
+        return phase1aOutcome;
+    }
+    const snapshot = phase1aOutcome.snapshot;
+    let roundTrippedDefinition;
+    try {
+        const serialized = JSON.stringify(snapshot);
+        const deserialized = JSON.parse(serialized);
+        if (!deserialized?.definition) {
+            return {
+                kind: 'round_trip_failed',
+                workflowId,
+                cause: 'Definition lost during JSON round-trip',
+            };
+        }
+        roundTrippedDefinition = deserialized.definition;
+    }
+    catch (e) {
+        return {
+            kind: 'round_trip_failed',
+            workflowId,
+            cause: e instanceof Error ? e.message : String(e),
+        };
+    }
+    const executableWorkflow = Object.freeze({
+        kind: 'executable_workflow',
+        definition: roundTrippedDefinition,
+    });
+    const compiledExecutable = {};
+    const startabilityResult = validateStartability(workflow, snapshot, executableWorkflow, deps);
+    if (startabilityResult.isErr()) {
+        return { kind: 'startability_failed', workflowId, reason: startabilityResult.error };
+    }
+    const v1Compiled = deps.compiler.compile(workflow).unwrapOr(undefined);
+    if (!v1Compiled) {
+        throw new Error('Invariant violation: v1 compilation failed after already passing');
+    }
+    return {
+        kind: 'valid',
+        validated: {
+            kind: 'validated_workflow',
+            source: workflow,
+            executable: executableWorkflow,
+            compiledV1: v1Compiled,
+            compiledExecutable,
+        },
+    };
+}
+function validateStartability(authoredWorkflow, pinnedSnapshot, executableWorkflow, deps) {
+    const firstStepResult = deps.resolveFirstStep(authoredWorkflow, pinnedSnapshot);
+    if (firstStepResult.isErr()) {
+        return (0, neverthrow_1.err)(firstStepResult.error);
+    }
+    return (0, neverthrow_1.ok)(undefined);
+}

package/dist/application/use-cases/raw-workflow-file-scanner.d.ts

@@ -0,0 +1,18 @@
+import type { WorkflowDefinition } from '../../types/workflow-definition.js';
+export declare function findWorkflowJsonFiles(baseDirReal: string): Promise<string[]>;
+export type VariantKind = 'v2' | 'agentic' | 'standard';
+export interface ParsedRawWorkflowFile {
+    readonly kind: 'parsed';
+    readonly filePath: string;
+    readonly relativeFilePath: string;
+    readonly definition: WorkflowDefinition;
+    readonly variantKind: VariantKind;
+}
+export interface UnparseableRawWorkflowFile {
+    readonly kind: 'unparseable';
+    readonly filePath: string;
+    readonly relativeFilePath: string;
+    readonly error: string;
+}
+export type RawWorkflowFile = ParsedRawWorkflowFile | UnparseableRawWorkflowFile;
+export declare function scanRawWorkflowFiles(baseDirReal: string): Promise<RawWorkflowFile[]>;

package/dist/application/use-cases/raw-workflow-file-scanner.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findWorkflowJsonFiles = findWorkflowJsonFiles;
+exports.scanRawWorkflowFiles = scanRawWorkflowFiles;
+const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+async function findWorkflowJsonFiles(baseDirReal) {
+    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(baseDirReal);
+    return files;
+}
+async function scanRawWorkflowFiles(baseDirReal) {
+    const allJsonFiles = await findWorkflowJsonFiles(baseDirReal);
+    const results = [];
+    for (const filePath of allJsonFiles) {
+        const relativeFilePath = path_1.default.relative(baseDirReal, filePath);
+        try {
+            const stats = (0, fs_1.statSync)(filePath);
+            if (stats.size > 1000000) {
+                results.push({
+                    kind: 'unparseable',
+                    filePath,
+                    relativeFilePath,
+                    error: `File exceeds size limit (1MB): ${stats.size} bytes`,
+                });
+                continue;
+            }
+            const raw = await promises_1.default.readFile(filePath, 'utf-8');
+            const definition = JSON.parse(raw);
+            if (!isWorkflowDefinition(definition)) {
+                results.push({
+                    kind: 'unparseable',
+                    filePath,
+                    relativeFilePath,
+                    error: 'Invalid workflow definition structure (missing required fields)',
+                });
+                continue;
+            }
+            const variantKind = detectVariantKind(relativeFilePath);
+            results.push({
+                kind: 'parsed',
+                filePath,
+                relativeFilePath,
+                definition,
+                variantKind,
+            });
+        }
+        catch (e) {
+            results.push({
+                kind: 'unparseable',
+                filePath,
+                relativeFilePath,
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    return results;
+}
+function detectVariantKind(relativeFilePath) {
+    const normalized = relativeFilePath.replace(/\\/g, '/');
+    if (normalized.includes('.v2.'))
+        return 'v2';
+    if (normalized.includes('.agentic.'))
+        return 'agentic';
+    return 'standard';
+}
+function isWorkflowDefinition(obj) {
+    if (!obj || typeof obj !== 'object')
+        return false;
+    const def = obj;
+    return typeof def.id === 'string' && Array.isArray(def.steps);
+}

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

@@ -1,5 +1,6 @@
 import type { Workflow, WorkflowDefinition } from '../../types/workflow.js';
 import type { ValidationResult } from '../../types/validation.js';
+import { type ValidationPipelineDepsPhase1a } from '../services/workflow-validation-pipeline.js';
 export interface SchemaValidationResult {
     readonly valid: boolean;
     readonly errors: readonly string[];
@@ -33,6 +34,18 @@ export type ValidateWorkflowFileResult = {
     warnings?: readonly string[];
     info?: readonly string[];
     suggestions?: readonly string[];
+} | {
+    kind: 'v1_compilation_failed';
+    filePath: string;
+    message: string;
+} | {
+    kind: 'normalization_failed';
+    filePath: string;
+    message: string;
+} | {
+    kind: 'executable_compilation_failed';
+    filePath: string;
+    message: string;
 };
 export interface ValidateWorkflowFileDeps {
     readonly resolvePath: (filePath: string) => string;
@@ -43,4 +56,8 @@ export interface ValidateWorkflowFileDeps {
     readonly makeRuntimeWorkflow: (definition: WorkflowDefinition, resolvedPath: string) => Workflow;
     readonly validateRuntimeWorkflow: (workflow: Workflow) => ValidationResult;
 }
+export interface ValidateWorkflowFileDepsPipeline extends ValidateWorkflowFileDeps {
+    readonly validationPipelineDeps?: ValidationPipelineDepsPhase1a;
+}
 export declare function createValidateWorkflowFileUseCase(deps: ValidateWorkflowFileDeps): (filePath: string) => ValidateWorkflowFileResult;
+export declare function createValidateWorkflowFileUseCasePipeline(deps: ValidateWorkflowFileDepsPipeline): (filePath: string) => ValidateWorkflowFileResult;

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createValidateWorkflowFileUseCase = createValidateWorkflowFileUseCase;
+exports.createValidateWorkflowFileUseCasePipeline = createValidateWorkflowFileUseCasePipeline;
+const workflow_validation_pipeline_js_1 = require("../services/workflow-validation-pipeline.js");
 function createValidateWorkflowFileUseCase(deps) {
     return function validateWorkflowFile(filePath) {
         const resolvedPath = deps.resolvePath(filePath);
@@ -55,3 +57,97 @@ function createValidateWorkflowFileUseCase(deps) {
         };
     };
 }
+function createValidateWorkflowFileUseCasePipeline(deps) {
+    return function validateWorkflowFilePipeline(filePath) {
+        const resolvedPath = deps.resolvePath(filePath);
+        if (!deps.existsSync(resolvedPath)) {
+            return { kind: 'file_not_found', filePath };
+        }
+        let content;
+        try {
+            content = deps.readFileSyncUtf8(resolvedPath);
+        }
+        catch (err) {
+            return {
+                kind: 'read_error',
+                filePath,
+                message: err?.message ?? String(err),
+                code: err?.code,
+            };
+        }
+        let parsed;
+        try {
+            parsed = deps.parseJson(content);
+        }
+        catch (err) {
+            return { kind: 'json_parse_error', filePath, message: err?.message ?? String(err) };
+        }
+        const definition = parsed;
+        const runtimeWorkflow = deps.makeRuntimeWorkflow(definition, resolvedPath);
+        if (deps.validationPipelineDeps) {
+            const outcome = (0, workflow_validation_pipeline_js_1.validateWorkflowPhase1a)(runtimeWorkflow, deps.validationPipelineDeps);
+            switch (outcome.kind) {
+                case 'schema_failed':
+                    return {
+                        kind: 'schema_invalid',
+                        filePath,
+                        errors: outcome.errors.map(e => e.message || `Schema error at ${e.instancePath}`),
+                    };
+                case 'structural_failed':
+                    return {
+                        kind: 'structural_invalid',
+                        filePath,
+                        issues: outcome.issues,
+                    };
+                case 'v1_compilation_failed':
+                    return {
+                        kind: 'v1_compilation_failed',
+                        filePath,
+                        message: outcome.cause.message,
+                    };
+                case 'normalization_failed':
+                    return {
+                        kind: 'normalization_failed',
+                        filePath,
+                        message: outcome.cause.message,
+                    };
+                case 'executable_compilation_failed':
+                    return {
+                        kind: 'executable_compilation_failed',
+                        filePath,
+                        message: outcome.cause.message,
+                    };
+                case 'phase1a_valid':
+                    return {
+                        kind: 'valid',
+                        filePath,
+                    };
+            }
+        }
+        const schemaResult = deps.schemaValidate(definition);
+        if (!schemaResult.valid) {
+            return { kind: 'schema_invalid', filePath, errors: schemaResult.errors };
+        }
+        const structural = deps.validateRuntimeWorkflow(runtimeWorkflow);
+        if (structural.valid) {
+            const warnings = structural.warnings?.length ? structural.warnings : undefined;
+            const info = structural.info?.length ? structural.info : undefined;
+            const suggestions = structural.suggestions.length ? structural.suggestions : undefined;
+            return {
+                kind: 'valid',
+                filePath,
+                warnings,
+                info,
+                suggestions,
+            };
+        }
+        return {
+            kind: 'structural_invalid',
+            filePath,
+            issues: structural.issues,
+            warnings: structural.warnings,
+            info: structural.info,
+            suggestions: structural.suggestions.length ? structural.suggestions : undefined,
+        };
+    };
+}

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

@@ -1,7 +1,8 @@
+import { type ValidationPipelineDepsPhase1a } from '../services/workflow-validation-pipeline.js';
 export interface WorkflowJsonValidationResult {
     valid: boolean;
     issues: string[];
     suggestions: string[];
 }
-export declare function createValidateWorkflowJson(): (workflowJson: string) => Promise<WorkflowJsonValidationResult>;
+export declare function createValidateWorkflowJson(deps?: ValidationPipelineDepsPhase1a): (workflowJson: string) => Promise<WorkflowJsonValidationResult>;
 export declare function validateWorkflowJson(workflowJson: string): Promise<WorkflowJsonValidationResult>;

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

@@ -2,8 +2,63 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createValidateWorkflowJson = createValidateWorkflowJson;
 exports.validateWorkflowJson = validateWorkflowJson;
-const validation_1 = require("../validation");
-function createValidateWorkflowJson() {
+const validation_js_1 = require("../validation.js");
+const workflow_validation_pipeline_js_1 = require("../services/workflow-validation-pipeline.js");
+const validation_engine_js_1 = require("../services/validation-engine.js");
+const enhanced_loop_validator_js_1 = require("../services/enhanced-loop-validator.js");
+const workflow_compiler_js_1 = require("../services/workflow-compiler.js");
+const v1_to_v2_shim_js_1 = require("../../v2/read-only/v1-to-v2-shim.js");
+const workflow_js_1 = require("../../types/workflow.js");
+const workflow_source_js_1 = require("../../types/workflow-source.js");
+function buildDefaultPipelineDeps() {
+    const loopValidator = new enhanced_loop_validator_js_1.EnhancedLoopValidator();
+    const validationEngine = new validation_engine_js_1.ValidationEngine(loopValidator);
+    const compiler = new workflow_compiler_js_1.WorkflowCompiler();
+    return {
+        schemaValidate: validation_js_1.validateWorkflowSchema,
+        structuralValidate: validationEngine.validateWorkflowStructureOnly.bind(validationEngine),
+        compiler,
+        normalizeToExecutable: v1_to_v2_shim_js_1.normalizeV1WorkflowToPinnedSnapshot,
+    };
+}
+function mapOutcomeToResult(outcome) {
+    switch (outcome.kind) {
+        case 'schema_failed':
+            return {
+                valid: false,
+                issues: outcome.errors.map(e => e.message ?? e.keyword ?? 'Schema validation error').filter(Boolean),
+                suggestions: generateSuggestions(outcome.errors.map(e => e.message ?? '').filter(Boolean)),
+            };
+        case 'structural_failed':
+            return {
+                valid: false,
+                issues: outcome.issues.slice(),
+                suggestions: generateSuggestions(outcome.issues.slice()),
+            };
+        case 'v1_compilation_failed':
+            return {
+                valid: false,
+                issues: [`Compilation error: ${outcome.cause.message}`],
+                suggestions: ['Check step references, loop definitions, and prompt sources.'],
+            };
+        case 'normalization_failed':
+            return {
+                valid: false,
+                issues: [`Normalization error: ${outcome.cause.message}`],
+                suggestions: ['Check templateCall references, promptBlocks, and step definitions.'],
+            };
+        case 'executable_compilation_failed':
+            return {
+                valid: false,
+                issues: [`Executable compilation error: ${outcome.cause.message}`],
+                suggestions: ['The normalized workflow has an internal conflict. Check that steps use exactly one of prompt, promptBlocks, or templateCall.'],
+            };
+        case 'phase1a_valid':
+            return { valid: true, issues: [], suggestions: [] };
+    }
+}
+function createValidateWorkflowJson(deps) {
+    const pipelineDeps = deps ?? buildDefaultPipelineDeps();
     return async (workflowJson) => {
         if (workflowJson === null || workflowJson === undefined || typeof workflowJson !== 'string') {
             return {
@@ -37,18 +92,17 @@ function createValidateWorkflowJson() {
                 ]
             };
         }
-        const validationResult = (0, validation_1.validateWorkflow)(parsedWorkflow);
-        const issues = [];
-        const suggestions = [];
-        if (!validationResult.valid) {
-            issues.push(...validationResult.errors);
-            suggestions.push(...generateSuggestions(validationResult.errors));
+        if (typeof parsedWorkflow !== 'object' || parsedWorkflow === null || Array.isArray(parsedWorkflow)) {
+            return {
+                valid: false,
+                issues: ['Workflow JSON must be an object, not a primitive or array.'],
+                suggestions: ['Provide a JSON object with fields: id, name, description, version, steps.'],
+            };
         }
-        return {
-            valid: validationResult.valid,
-            issues,
-            suggestions
-        };
+        const definition = parsedWorkflow;
+        const workflow = (0, workflow_js_1.createWorkflow)(definition, (0, workflow_source_js_1.createBundledSource)());
+        const outcome = (0, workflow_validation_pipeline_js_1.validateWorkflowPhase1a)(workflow, pipelineDeps);
+        return mapOutcomeToResult(outcome);
     };
 }
 function generateSuggestions(errors) {